[Cast] Size-Adaptable platform video encoders.

media/cast/test/end2end_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.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
@@ skipping 35 matching lines @@
 namespace cast {
 
 namespace {
 
 static const int64 kStartMillisecond = INT64_C(1245);
 static const int kAudioChannels = 2;
 static const double kSoundFrequency = 314.15926535897;  // Freq of sine wave.
 static const float kSoundVolume = 0.5f;
 static const int kVideoHdWidth = 1280;
 static const int kVideoHdHeight = 720;
-static const int kVideoQcifWidth = 176;
-static const int kVideoQcifHeight = 144;
 
 // Since the video encoded and decoded an error will be introduced; when
 // comparing individual pixels the error can be quite large; we allow a PSNR of
 // at least |kVideoAcceptedPSNR|.
 static const double kVideoAcceptedPSNR = 38.0;
 
 // The tests are commonly implemented with |kFrameTimerMs| RunTask function;
 // a normal video is 30 fps hence the 33 ms between frames.
 //
 // TODO(miu): The errors in timing will add up significantly.  Find an
@@ skipping 281 matching lines @@
   std::list<ExpectedAudioFrame*> expected_frames_;
   base::TimeTicks last_playout_time_;
 };
 
 // Class that verifies the video frames coming out of the receiver.
 class TestReceiverVideoCallback
     : public base::RefCountedThreadSafe<TestReceiverVideoCallback> {
  public:
   struct ExpectedVideoFrame {
     int start_value;
-    int width;
-    int height;
     base::TimeTicks playout_time;
     bool should_be_continuous;
   };
 
   TestReceiverVideoCallback() : num_called_(0) {}
 
   void AddExpectedResult(int start_value,
-                         int width,
-                         int height,
                          const base::TimeTicks& playout_time,
                          bool should_be_continuous) {
     ExpectedVideoFrame expected_video_frame;
     expected_video_frame.start_value = start_value;
-    expected_video_frame.width = width;
-    expected_video_frame.height = height;
     expected_video_frame.playout_time = playout_time;
     expected_video_frame.should_be_continuous = should_be_continuous;
     expected_frame_.push_back(expected_video_frame);
   }
 
   void CheckVideoFrame(const scoped_refptr<media::VideoFrame>& video_frame,
                        const base::TimeTicks& playout_time,
                        bool is_continuous) {
     ++num_called_;
 
     ASSERT_TRUE(!!video_frame.get());
     ASSERT_FALSE(expected_frame_.empty());
     ExpectedVideoFrame expected_video_frame = expected_frame_.front();
     expected_frame_.pop_front();
 
-    EXPECT_EQ(expected_video_frame.width, video_frame->visible_rect().width());
-    EXPECT_EQ(expected_video_frame.height,
-              video_frame->visible_rect().height());
+    EXPECT_EQ(kVideoHdWidth, video_frame->visible_rect().width());
+    EXPECT_EQ(kVideoHdHeight, video_frame->visible_rect().height());
 
-    gfx::Size size(expected_video_frame.width, expected_video_frame.height);
+    const gfx::Size size(kVideoHdWidth, kVideoHdHeight);
     scoped_refptr<media::VideoFrame> expected_I420_frame =
         media::VideoFrame::CreateFrame(
             VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
     PopulateVideoFrame(expected_I420_frame.get(),
                        expected_video_frame.start_value);
 
     if (expected_video_frame.should_be_continuous) {
       EXPECT_GE(I420PSNR(expected_I420_frame, video_frame), kVideoAcceptedPSNR);
     }
 
@@ skipping 83 matching lines @@
 
     test_receiver_audio_callback_->SetExpectedSamplingFrequency(
         audio_receiver_config_.rtp_timebase);
 
     video_sender_config_.ssrc = 3;
     video_sender_config_.receiver_ssrc = 4;
     video_sender_config_.max_playout_delay =
         base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs);
     video_sender_config_.rtp_payload_type = 97;
     video_sender_config_.use_external_encoder = false;
-    video_sender_config_.width = kVideoHdWidth;
-    video_sender_config_.height = kVideoHdHeight;
     video_sender_config_.max_bitrate = 50000;
     video_sender_config_.min_bitrate = 10000;
     video_sender_config_.start_bitrate = 10000;
     video_sender_config_.max_qp = 30;
     video_sender_config_.min_qp = 4;
     video_sender_config_.max_frame_rate = 30;
     video_sender_config_.max_number_of_video_buffers_used =
         max_number_of_video_buffers_used;
     video_sender_config_.codec = video_codec;
 
@@ skipping 148 matching lines @@
     cast_receiver_.reset();
     task_runner_->RunTasks();
   }
 
   void SendVideoFrame(int start_value, const base::TimeTicks& reference_time) {
     if (start_time_.is_null())
       start_time_ = reference_time;
     // TODO(miu): Consider using a slightly skewed clock for the media timestamp
     // since the video clock may not be the same as the reference clock.
     const base::TimeDelta time_diff = reference_time - start_time_;
-    gfx::Size size(video_sender_config_.width, video_sender_config_.height);
+    const gfx::Size size(kVideoHdWidth, kVideoHdHeight);
     EXPECT_TRUE(VideoFrame::IsValidConfig(
         VideoFrame::I420, size, gfx::Rect(size), size));
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateFrame(
             VideoFrame::I420, size, gfx::Rect(size), size,
             time_diff);
     PopulateVideoFrame(video_frame.get(), start_value);
     video_frame_input_->InsertRawVideoFrame(video_frame, reference_time);
   }
 
@@ skipping 147 matching lines @@
   std::vector<FrameEvent> frame_events_;
   std::vector<PacketEvent> packet_events_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_;
   // |transport_sender_| has a RepeatingTimer which needs a MessageLoop.
   base::MessageLoop message_loop_;
 };
 
 TEST_F(End2EndTest, LoopNoLossPcm16) {
   Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
-  // Reduce video resolution to allow processing multiple frames within a
-  // reasonable time frame.
-  video_sender_config_.width = kVideoQcifWidth;
-  video_sender_config_.height = kVideoQcifHeight;
   Create();
 
   const int kNumIterations = 50;
   int video_start = kVideoStart;
   int audio_diff = kFrameTimerMs;
   int num_audio_frames_requested = 0;
   for (int i = 0; i < kNumIterations; ++i) {
     const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
     audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
     if (num_audio_frames > 0)
       FeedAudioFrames(1, true);
 
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
-        video_sender_config_.width,
-        video_sender_config_.height,
         testing_clock_sender_->NowTicks() +
             base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
         true);
     SendVideoFrame(video_start, testing_clock_sender_->NowTicks());
 
     if (num_audio_frames > 0)
       RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
     if (num_audio_frames > 1)
       FeedAudioFrames(num_audio_frames - 1, true);
 
@@ skipping 84 matching lines @@
     audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
     if (num_audio_frames > 0)
       FeedAudioFramesWithExpectedDelay(1, expected_delay);
 
     // Frame will be rendered with 100mS delay, as the transmission is delayed.
     // The receiver at this point cannot be synced to the sender's clock, as no
     // packets, and specifically no RTCP packets were sent.
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
-        video_sender_config_.width,
-        video_sender_config_.height,
         initial_send_time + expected_delay +
             base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
         true);
     SendVideoFrame(video_start, testing_clock_sender_->NowTicks());
 
     if (num_audio_frames > 0)
       RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
     if (num_audio_frames > 1)
       FeedAudioFramesWithExpectedDelay(num_audio_frames - 1, expected_delay);
 
     RunTasks(kFrameTimerMs - kAudioFrameDurationMs);
     audio_diff += kFrameTimerMs;
     video_start++;
   }
 
   RunTasks(test_delay_ms);
   sender_to_receiver_.SetSendPackets(true);
 
   int num_audio_frames_requested = 0;
   for (int j = 0; j < 10; ++j) {
     const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
     audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
     if (num_audio_frames > 0)
       FeedAudioFrames(1, true);
 
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
-        video_sender_config_.width,
-        video_sender_config_.height,
         testing_clock_sender_->NowTicks() +
             base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
         true);
     SendVideoFrame(video_start, testing_clock_sender_->NowTicks());
 
     if (num_audio_frames > 0)
       RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
     if (num_audio_frames > 1)
       FeedAudioFrames(num_audio_frames - 1, true);
 
@@ skipping 29 matching lines @@
   base::TimeTicks reference_time;
 
   int i = 0;
   for (; i < 20; ++i) {
     reference_time = testing_clock_sender_->NowTicks();
     SendVideoFrame(video_start, reference_time);
 
     if (i % 2 == 0) {
       test_receiver_video_callback_->AddExpectedResult(
           video_start,
-          video_sender_config_.width,
-          video_sender_config_.height,
           reference_time + base::TimeDelta::FromMilliseconds(target_delay),
           i == 0);
 
       // GetRawVideoFrame will not return the frame until we are close in
       // time before we should render the frame.
       cast_receiver_->RequestDecodedVideoFrame(
           base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                      test_receiver_video_callback_));
     }
     RunTasks(kFrameTimerMs);
@@ skipping 19 matching lines @@
 
   Create();
 
   int frames_counter = 0;
   for (; frames_counter < 3; ++frames_counter) {
     const base::TimeTicks reference_time = testing_clock_sender_->NowTicks();
     SendVideoFrame(frames_counter, reference_time);
 
     test_receiver_video_callback_->AddExpectedResult(
         frames_counter,
-        video_sender_config_.width,
-        video_sender_config_.height,
         reference_time +
             base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
         true);
 
     RunTasks(kFrameTimerMs);
 
     cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
   }
@@ skipping 34 matching lines @@
 TEST_F(End2EndTest, VideoLogging) {
   Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_PCM16, 32000, 1);
   Create();
 
   int video_start = kVideoStart;
   const int num_frames = 5;
   for (int i = 0; i < num_frames; ++i) {
     base::TimeTicks reference_time = testing_clock_sender_->NowTicks();
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
-        video_sender_config_.width,
-        video_sender_config_.height,
         reference_time +
             base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs),
         true);
 
     SendVideoFrame(video_start, reference_time);
     RunTasks(kFrameTimerMs);
 
     cast_receiver_->RequestDecodedVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
@@ skipping 387 matching lines @@
   EXPECT_LT(jump, 220u);
 }
 
 // TODO(pwestin): Add repeatable packet loss test.
 // TODO(pwestin): Add test for misaligned send get calls.
 // TODO(pwestin): Add more tests that does not resample.
 // TODO(pwestin): Add test when we have starvation for our RunTask.
 
 }  // namespace cast
 }  // namespace media