[Cast] Size-Adaptable platform video encoders.

media/cast/sender/video_sender_unittest.cc

 // Copyright 2014 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 <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/logging/simple_event_subscriber.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_sender_impl.h"
 #include "media/cast/net/pacing/paced_sender.h"
+#include "media/cast/sender/fake_video_encode_accelerator_factory.h"
 #include "media/cast/sender/video_frame_factory.h"
 #include "media/cast/sender/video_sender.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/video/fake_video_encode_accelerator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 static const uint8 kPixelValue = 123;
 static const int kWidth = 320;
 static const int kHeight = 240;
 
 using testing::_;
 using testing::AtLeast;
 
-void CreateVideoEncodeAccelerator(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    scoped_ptr<VideoEncodeAccelerator> fake_vea,
-    const ReceiveVideoEncodeAcceleratorCallback& callback) {
-  callback.Run(task_runner, fake_vea.Pass());
-}
-
-void CreateSharedMemory(
-    size_t size, const ReceiveVideoEncodeMemoryCallback& callback) {
-  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
-  if (!shm->CreateAndMapAnonymous(size)) {
-    NOTREACHED();
-    return;
-  }
-  callback.Run(shm.Pass());
-}
 
 void SaveOperationalStatus(OperationalStatus* out_status,
                            OperationalStatus in_status) {
   DVLOG(1) << "OperationalStatus transitioning from " << *out_status << " to "
            << in_status;
   *out_status = in_status;
 }
 
 class TestPacketSender : public PacketSender {
  public:
@@ skipping 74 matching lines @@
  protected:
   VideoSenderTest()
       : testing_clock_(new base::SimpleTestTickClock()),
         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
         cast_environment_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_).Pass(),
             task_runner_,
             task_runner_,
             task_runner_)),
         operational_status_(STATUS_UNINITIALIZED),
-        stored_bitrates_(NULL) {
+        vea_factory_(task_runner_) {
     testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
+    vea_factory_.SetAutoRespond(true);
     last_pixel_value_ = kPixelValue;
     net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new CastTransportSenderImpl(
         NULL,
         testing_clock_,
         dummy_endpoint,
         dummy_endpoint,
         make_scoped_ptr(new base::DictionaryValue),
         base::Bind(&UpdateCastTransportStatus),
         BulkRawEventsCallback(),
@@ skipping 15 matching lines @@
   }
 
   // If |external| is true then external video encoder (VEA) is used.
   // |expect_init_sucess| is true if initialization is expected to succeed.
   void InitEncoder(bool external, bool expect_init_success) {
     VideoSenderConfig video_config;
     video_config.ssrc = 1;
     video_config.receiver_ssrc = 2;
     video_config.rtp_payload_type = 127;
     video_config.use_external_encoder = external;
-    video_config.width = kWidth;
-    video_config.height = kHeight;
     video_config.max_bitrate = 5000000;
     video_config.min_bitrate = 1000000;
     video_config.start_bitrate = 1000000;
     video_config.max_qp = 56;
     video_config.min_qp = 0;
     video_config.max_frame_rate = 30;
     video_config.max_number_of_video_buffers_used = 1;
     video_config.codec = CODEC_VIDEO_VP8;
 
     ASSERT_EQ(operational_status_, STATUS_UNINITIALIZED);
 
     if (external) {
-      media::FakeVideoEncodeAccelerator* fake_vea =
-          new media::FakeVideoEncodeAccelerator(task_runner_);
-      stored_bitrates_ = &fake_vea->stored_bitrates();
-      fake_vea->SetWillInitializationSucceed(expect_init_success);
-      scoped_ptr<VideoEncodeAccelerator> fake_vea_owner(fake_vea);
-      video_sender_.reset(
-          new PeerVideoSender(cast_environment_,
-                              video_config,
-                              base::Bind(&SaveOperationalStatus,
-                                         &operational_status_),
-                              base::Bind(&CreateVideoEncodeAccelerator,
-                                         task_runner_,
-                                         base::Passed(&fake_vea_owner)),
-                              base::Bind(&CreateSharedMemory),
-                              transport_sender_.get()));
+      vea_factory_.SetInitializationWillSucceed(expect_init_success);
+      video_sender_.reset(new PeerVideoSender(
+          cast_environment_,
+          video_config,
+          base::Bind(&SaveOperationalStatus, &operational_status_),
+          base::Bind(
+              &FakeVideoEncodeAcceleratorFactory::CreateVideoEncodeAccelerator,
+              base::Unretained(&vea_factory_)),
+          base::Bind(&FakeVideoEncodeAcceleratorFactory::CreateSharedMemory,
+                     base::Unretained(&vea_factory_)),
+          transport_sender_.get()));
     } else {
-      video_sender_.reset(
-          new PeerVideoSender(cast_environment_,
-                              video_config,
-                              base::Bind(&SaveOperationalStatus,
-                                         &operational_status_),
-                              CreateDefaultVideoEncodeAcceleratorCallback(),
-                              CreateDefaultVideoEncodeMemoryCallback(),
-                              transport_sender_.get()));
+      video_sender_.reset(new PeerVideoSender(
+          cast_environment_,
+          video_config,
+          base::Bind(&SaveOperationalStatus, &operational_status_),
+          CreateDefaultVideoEncodeAcceleratorCallback(),
+          CreateDefaultVideoEncodeMemoryCallback(),
+          transport_sender_.get()));
     }
     task_runner_->RunTasks();
   }
 
   scoped_refptr<media::VideoFrame> GetNewVideoFrame() {
     if (first_frame_timestamp_.is_null())
       first_frame_timestamp_ = testing_clock_->NowTicks();
     gfx::Size size(kWidth, kHeight);
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateFrame(
@@ skipping 16 matching lines @@
   }
 
   void RunTasks(int during_ms) {
     task_runner_->Sleep(base::TimeDelta::FromMilliseconds(during_ms));
   }
 
   base::SimpleTestTickClock* const testing_clock_;  // Owned by CastEnvironment.
   const scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   const scoped_refptr<CastEnvironment> cast_environment_;
   OperationalStatus operational_status_;
+  FakeVideoEncodeAcceleratorFactory vea_factory_;
   TestPacketSender transport_;
   scoped_ptr<CastTransportSenderImpl> transport_sender_;
   scoped_ptr<PeerVideoSender> video_sender_;
-  const std::vector<uint32>* stored_bitrates_;  // Owned by |video_sender_|.
   int last_pixel_value_;
   base::TimeTicks first_frame_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoSenderTest);
 };
 
 TEST_F(VideoSenderTest, BuiltInEncoder) {
   InitEncoder(false, true);
   ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
   const base::TimeTicks reference_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, reference_time);
 
   task_runner_->RunTasks();
   EXPECT_LE(1, transport_.number_of_rtp_packets());
   EXPECT_LE(1, transport_.number_of_rtcp_packets());
 }
 
 TEST_F(VideoSenderTest, ExternalEncoder) {
   InitEncoder(true, true);
   ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
 
+  // The SizeAdaptableExternalVideoEncoder initally reports STATUS_INITIALIZED
+  // so that frames will be sent to it.  Therefore, no encoder activity should
+  // have occurred at this point.  Send a frame to spurn creation of the
+  // underlying ExternalVideoEncoder instance.
+  if (vea_factory_.vea_response_count() == 0) {
+    video_sender_->InsertRawVideoFrame(GetNewVideoFrame(),
+                                       testing_clock_->NowTicks());
+    task_runner_->RunTasks();
+  }
+  ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
+  RunTasks(33);
+
+  // VideoSender created an encoder for 1280x720 frames, in order to provide the
+  // INITIALIZED status.
+  EXPECT_EQ(1, vea_factory_.vea_response_count());
+  EXPECT_EQ(3, vea_factory_.shm_response_count());
+
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
-  const base::TimeTicks reference_time = testing_clock_->NowTicks();
-  video_sender_->InsertRawVideoFrame(video_frame, reference_time);
-  task_runner_->RunTasks();
-  video_sender_->InsertRawVideoFrame(video_frame, reference_time);
-  task_runner_->RunTasks();
-  video_sender_->InsertRawVideoFrame(video_frame, reference_time);
-  task_runner_->RunTasks();
+  for (int i = 0; i < 3; ++i) {
+    const base::TimeTicks reference_time = testing_clock_->NowTicks();
+    video_sender_->InsertRawVideoFrame(video_frame, reference_time);
+    RunTasks(33);
+    // VideoSender re-created the encoder for the 320x240 frames we're
+    // providing.
+    EXPECT_EQ(1, vea_factory_.vea_response_count());
+    EXPECT_EQ(3, vea_factory_.shm_response_count());
+  }
 
-  // Fixed bitrate is used for external encoder. Bitrate is only once
-  // to the encoder.
-  EXPECT_EQ(1u, stored_bitrates_->size());
   video_sender_.reset(NULL);
   task_runner_->RunTasks();
+  EXPECT_EQ(1, vea_factory_.vea_response_count());
+  EXPECT_EQ(3, vea_factory_.shm_response_count());
 }
 
 TEST_F(VideoSenderTest, ExternalEncoderInitFails) {
   InitEncoder(true, false);
+
+  // The SizeAdaptableExternalVideoEncoder initally reports STATUS_INITIALIZED
+  // so that frames will be sent to it.  Send a frame to spurn creation of the
+  // underlying ExternalVideoEncoder instance, which should result in failure.
+  if (operational_status_ == STATUS_INITIALIZED ||
+      operational_status_ == STATUS_CODEC_REINIT_PENDING) {
+    video_sender_->InsertRawVideoFrame(GetNewVideoFrame(),
+                                       testing_clock_->NowTicks());
+    task_runner_->RunTasks();
+  }
   EXPECT_EQ(STATUS_CODEC_INIT_FAILED, operational_status_);
 
   video_sender_.reset(NULL);
   task_runner_->RunTasks();
 }
 
 TEST_F(VideoSenderTest, RtcpTimer) {
   InitEncoder(false, true);
   ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
 
@@ skipping 246 matching lines @@
 
 TEST_F(VideoSenderTest, CheckVideoFrameFactoryIsNull) {
   InitEncoder(false, true);
   ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
 
   EXPECT_EQ(nullptr, video_sender_->CreateVideoFrameFactory().get());
 }
 
 }  // namespace cast
 }  // namespace media