H264 HW encode using VideoToolbox

content/common/gpu/media/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 <queue>
 #include <string>
@@ skipping 37 matching lines @@
 #if defined(OS_CHROMEOS)
 #if defined(ARCH_CPU_ARMEL) || (defined(USE_OZONE) && defined(USE_V4L2_CODEC))
 #include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "content/common/gpu/media/vaapi_video_encode_accelerator.h"
 #include "content/common/gpu/media/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 "content/common/gpu/media/vt_video_encode_accelerator.h"
 #else
 #error The VideoEncodeAcceleratorUnittest is not supported on this platform.
 #endif
 
 using media::VideoEncodeAccelerator;
 
 namespace content {
 namespace {
 
 const media::VideoPixelFormat kInputFormat = media::PIXEL_FORMAT_I420;
@@ skipping 51 matching lines @@
 // 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
 
 // 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 501 matching lines @@
   State decoder_state_;
   std::queue<scoped_refptr<media::VideoFrame>> original_frames_;
   std::queue<scoped_refptr<media::DecoderBuffer>> decode_buffers_;
 };
 
 VideoFrameQualityValidator::VideoFrameQualityValidator(
     const media::VideoCodecProfile profile,
     const base::Closure& flush_complete_cb,
     const base::Closure& decode_error_cb)
     : profile_(profile),
       decoder_(new media::FFmpegVideoDecoder()),

[Pawel Osciak, 2016/02/08 04:33:42]

Did you mean ffmpeg was just not compiled/working on Mac at all, or that it
would fail for some other reason? I thought ffmpeg worked on Mac...

[emircan, 2016/02/08 23:41:23]

It points to this line when built:
https://code.google.com/p/chromium/codesearch#chromium/src/content/common/gpu....
Do you know if it is still the case?

[Pawel Osciak, 2016/02/18 11:16:13]

Are you building and testing on Chromium, instead of Chrome?

[emircan, 2016/03/03 19:18:19]

I built with ffmpeg branding and it works fine now.  I will turn on the unit
test to verify frames now.

       decode_cb_(base::Bind(&VideoFrameQualityValidator::DecodeDone,
                             base::Unretained(this))),
       eos_decode_cb_(base::Bind(&VideoFrameQualityValidator::FlushDone,
                                 base::Unretained(this))),
       flush_complete_cb_(flush_complete_cb),
       decode_error_cb_(decode_error_cb),
       decoder_state_(UNINITIALIZED) {
   // Allow decoding of individual NALU. Entire frames are required by default.
   decoder_->set_decode_nalus(true);
 }
@@ skipping 141 matching lines @@
 
  private:
   bool has_encoder() { return encoder_.get(); }
 
   // Return the number of encoded frames per second.
   double frames_per_second();
 
   scoped_ptr<media::VideoEncodeAccelerator> CreateFakeVEA();
   scoped_ptr<media::VideoEncodeAccelerator> CreateV4L2VEA();
   scoped_ptr<media::VideoEncodeAccelerator> CreateVaapiVEA();
+  scoped_ptr<media::VideoEncodeAccelerator> CreateVTVEA();
 
   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 241 matching lines @@
 }
 
 scoped_ptr<media::VideoEncodeAccelerator> VEAClient::CreateVaapiVEA() {
   scoped_ptr<media::VideoEncodeAccelerator> encoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   encoder.reset(new VaapiVideoEncodeAccelerator());
 #endif
   return encoder;
 }
 
+scoped_ptr<media::VideoEncodeAccelerator> VEAClient::CreateVTVEA() {
+  scoped_ptr<media::VideoEncodeAccelerator> encoder;
+#if defined(OS_MACOSX)
+  encoder.reset(new VTVideoEncodeAccelerator());
+#endif
+  return encoder;
+}
+
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG_ASSERT(!has_encoder());
 
   scoped_ptr<media::VideoEncodeAccelerator> encoders[] = {
     CreateFakeVEA(),
     CreateV4L2VEA(),
-    CreateVaapiVEA()
+    CreateVaapiVEA(),
+    CreateVTVEA()
   };
 
   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);
@@ skipping 550 matching lines @@
   for (size_t i = 0; i < num_concurrent_encoders; ++i) {
     encoder_thread.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&VEAClient::DestroyEncoder, base::Unretained(clients[i])));
   }
 
   // This ensures all tasks have finished.
   encoder_thread.Stop();
 }
 
+#if !defined(OS_MACOSX)
 INSTANTIATE_TEST_CASE_P(
     SimpleEncode,
     VideoEncodeAcceleratorTest,
     ::testing::Values(
         base::MakeTuple(1, true, 0, false, false, false, false, false),
         base::MakeTuple(1, true, 0, false, false, false, false, true)));
 
 INSTANTIATE_TEST_CASE_P(
     EncoderPerf,
     VideoEncodeAcceleratorTest,
@@ skipping 24 matching lines @@
     ::testing::Values(
         base::MakeTuple(1, false, 0, true, false, false, true, false)));
 
 INSTANTIATE_TEST_CASE_P(
     MultipleEncoders,
     VideoEncodeAcceleratorTest,
     ::testing::Values(
         base::MakeTuple(3, false, 0, false, false, false, false, false),
         base::MakeTuple(3, false, 0, true, false, false, true, false),
         base::MakeTuple(3, false, 0, true, false, true, false, false)));
+#else

[Pawel Osciak, 2016/02/08 04:33:42]

Even if framerate changes are not supported, perhaps we could still test bitrate
changes?

[emircan, 2016/02/08 23:41:23]

Actually, bitrate code isn't doing much as VT does not allow reconfiguration
while in session. See
https://code.google.com/p/chromium/codesearch#chromium/src/media/cast/sender/...
and https://code.google.com/p/chromium/issues/detail?id=425352 . I will add a
comment regarding this in that section as well. 

+INSTANTIATE_TEST_CASE_P(
+    SimpleEncode,
+    VideoEncodeAcceleratorTest,
+    ::testing::Values(
+        base::MakeTuple(1, true, 0, false, false, false, false, false)));
+
+INSTANTIATE_TEST_CASE_P(
+    EncoderPerf,
+    VideoEncodeAcceleratorTest,
+    ::testing::Values(
+        base::MakeTuple(1, false, 0, false, true, false, false, false)));
+
+INSTANTIATE_TEST_CASE_P(
+    MultipleEncoders,
+    VideoEncodeAcceleratorTest,
+    ::testing::Values(
+        base::MakeTuple(3, false, 0, false, false, false, false, false)));
+#endif
 
 // TODO(posciak): more tests:
 // - async FeedEncoderWithOutput
 // - out-of-order return of outputs to encoder
 // - multiple encoders + decoders
 // - mid-stream encoder_->Destroy()
 
 }  // namespace
 }  // namespace content
 
@@ skipping 77 matching lines @@
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }