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 26 matching lines @@
 // an encoder to be able to converge to the requested bitrate over.
 // The input stream will be looped as many times as needed in bitrate tests
 // to reach at least this number of frames before calculating final bitrate.
 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"
+// "in_filename&width&height&profile&out_filename&requested_bitrate
+//  &requested_framerate&requested_subsequent_bitrate
+//  &requested_subsequent_framerate"
 // - |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 char* g_default_in_parameters = "&320&192&1&out.h264&200000";

[wuchengli, 2016/07/15 13:39:40]

Why do we need to change from ":" to "&"? Several ChromeOS autotest pass this
string and will break.

[emircan, 2016/07/16 06:56:38]

In windows file paths contain ":", i.e. C:\Program Files. I spent a long time
finding out the issue with this actually. I can keep ":" as the seperator and
write some "#if WIN" code to handle it specifically. With "&", at least the
parsing code is uniform. WDYT?

[wuchengli, 2016/07/19 15:50:44]

- Uniform parsing code is better. But we need to migrate ChromeOS autotest. One
way is to use "&" for #if OS_WIN and ":" for OS_CHROMEOS in this CL. In this CL,
also add an command line flag to use "&". After ChromeOS picks up this CL, we
can migrate autotest to pass the flag and use "&". Finally we can remove "&" in
video_encode_accelerator_unittest.cc. Before you change this, let me discuss
with Pawel tomorrow.

- With "&", the string is not easy to parse by eyes. Is there other separator we
can use? Or we can switch "&" and ";".

- I found we need to add "" if we use "&" separator. For example, it used to be 
./video_encode_accelerator_unittest
--test_stream_data=bear_320x192_40frames.yuv:320:192:1:out1.h264:200000:30:200000:30
Now it's
./video_encode_accelerator_unittest
--test_stream_data="bear_320x192_40frames.yuv&320&192&1&out1.h264&200000&30&200000&30"


- Can you make sure this won't break Mac? They may have some existing code that
pass : as separator like ChromeOS.

+#elif defined(OS_MACOSX)
+const char* g_default_in_parameters = "&320&192&0&out.h264&200000";

[wuchengli, 2016/07/15 13:39:40]

Can we make these all const base::FilePath::CharType*? So we can use he same
variable for OS_MACOSX and OS_WIN.

[emircan, 2016/07/16 06:56:38]

Done.

+#elif 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 135 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;
   }
 
+#if defined(OS_POSIX)
   base::FilePath src_file(test_stream->in_filename);
+#elif defined(OS_WIN)
+  base::FilePath src_file(base::UTF8ToWide(test_stream->in_filename));
+#endif
   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);
     LOG_ASSERT(fields.size() >= 4U) << data;
     LOG_ASSERT(fields.size() <= 9U) << data;
     TestStream* test_stream = new TestStream();
 
+#if defined(OS_POSIX)
     test_stream->in_filename = fields[0];

[wuchengli, 2016/07/15 13:39:40]

I don't understand. Why we only set in_filename for OS_POSIX and OS_WIN?

[emircan, 2016/07/16 06:56:38]

FilePath is defined specifically for POSIX and WIN. POSIX covers mac and cros.
https://cs.chromium.org/chromium/src/base/files/file_path.h?rcl=0&l=147

+#elif defined(OS_WIN)
+    test_stream->in_filename = base::WideToUTF8(fields[0]);

[wuchengli, 2016/07/15 13:39:40]

Make string conversion a function. It can be reused by line 301 and 1080. Maybe
line 395 can use the same function if we use template.

For example,
static std::string WideToUTFIfOSWin(std::string str) {
#if defined(OS_WIN)
  return base::WideToUTF8(str);
#endif
  return str;
}

Feel free to think of a better function name.

[emircan, 2016/07/16 06:56:38]

Done.

+#endif  // defined(OS_POSIX)
     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())
+    if (fields.size() >= 5 && !fields[4].empty()) {
+#if defined(OS_POSIX)
       test_stream->out_filename = fields[4];
+#elif defined(OS_WIN)
+      test_stream->out_filename = base::WideToUTF8(fields[4]);
+#endif  // defined(OS_POSIX)
+    }
 
     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();
 }