[Cast] Clean-up: Merge AudioReceiverConfig+VideoReceiverConfig-->FrameReceiverConfig.

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 443 matching lines @@
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_sender_->Logging()->AddRawEventSubscriber(
         &event_subscriber_sender_);
   }
 
   void Configure(transport::VideoCodec video_codec,
                  transport::AudioCodec audio_codec,
                  int audio_sampling_frequency,
-                 bool external_audio_decoder,
                  int max_number_of_video_buffers_used) {
     audio_sender_config_.rtp_config.ssrc = 1;
     audio_sender_config_.rtp_config.max_delay_ms = kTargetPlayoutDelayMs;
     audio_sender_config_.incoming_feedback_ssrc = 2;
     audio_sender_config_.rtp_config.payload_type = 96;
     audio_sender_config_.use_external_encoder = false;
     audio_sender_config_.frequency = audio_sampling_frequency;
     audio_sender_config_.channels = kAudioChannels;
     audio_sender_config_.bitrate = kDefaultAudioEncoderBitrate;
     audio_sender_config_.codec = audio_codec;
 
     audio_receiver_config_.feedback_ssrc =
         audio_sender_config_.incoming_feedback_ssrc;
     audio_receiver_config_.incoming_ssrc = audio_sender_config_.rtp_config.ssrc;
     audio_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs;
     audio_receiver_config_.rtp_payload_type =
         audio_sender_config_.rtp_config.payload_type;
-    audio_receiver_config_.use_external_decoder = external_audio_decoder;
     audio_receiver_config_.frequency = audio_sender_config_.frequency;
     audio_receiver_config_.channels = kAudioChannels;
-    audio_receiver_config_.codec = audio_sender_config_.codec;
+    audio_receiver_config_.max_frame_rate = 100;
+    audio_receiver_config_.codec.audio = audio_sender_config_.codec;
 
     test_receiver_audio_callback_->SetExpectedSamplingFrequency(
         audio_receiver_config_.frequency);
 
     video_sender_config_.rtp_config.ssrc = 3;
     video_sender_config_.rtp_config.max_delay_ms = kTargetPlayoutDelayMs;
     video_sender_config_.incoming_feedback_ssrc = 4;
     video_sender_config_.rtp_config.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;
 
     video_receiver_config_.feedback_ssrc =
         video_sender_config_.incoming_feedback_ssrc;
     video_receiver_config_.incoming_ssrc = video_sender_config_.rtp_config.ssrc;
     video_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs;
     video_receiver_config_.rtp_payload_type =
         video_sender_config_.rtp_config.payload_type;
-    video_receiver_config_.use_external_decoder = false;
-    video_receiver_config_.codec = video_sender_config_.codec;
+    video_receiver_config_.frequency = kVideoFrequency;
+    video_receiver_config_.channels = 1;
+    video_receiver_config_.max_frame_rate = video_sender_config_.max_frame_rate;
+    video_receiver_config_.codec.video = video_sender_config_.codec;
   }
 
   void SetReceiverSkew(double skew, base::TimeDelta offset) {
     testing_clock_receiver_->SetSkew(skew, offset);
     task_runner_receiver_->SetSkew(1.0 / skew);
   }
 
   // Specify the minimum/maximum difference in playout times between two
   // consecutive frames.  Also, specify the maximum absolute rate of change over
   // each three consecutive frames.
@@ skipping 199 matching lines @@
                                                              it->type,
                                                              it->media_type,
                                                              it->rtp_timestamp,
                                                              it->frame_id,
                                                              it->packet_id,
                                                              it->max_packet_id,
                                                              it->size);
     }
   }
 
-  AudioReceiverConfig audio_receiver_config_;
-  VideoReceiverConfig video_receiver_config_;
+  FrameReceiverConfig audio_receiver_config_;
+  FrameReceiverConfig video_receiver_config_;
   AudioSenderConfig audio_sender_config_;
   VideoSenderConfig video_sender_config_;
 
   base::TimeTicks start_time_;
 
   // These run in "test time"
   base::SimpleTestTickClock testing_clock_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
 
   // These run on the sender timeline.
@@ skipping 31 matching lines @@
   SimpleEventSubscriber event_subscriber_sender_;
   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(transport::kVp8, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kVp8, transport::kPcm16, 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;
@@ skipping 33 matching lines @@
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(num_audio_frames_requested,
             test_receiver_audio_callback_->number_times_called());
   EXPECT_EQ(kNumIterations,
             test_receiver_video_callback_->number_times_called());
 }
 
 // This tests our external decoder interface for Audio.
 // Audio test without packet loss using raw PCM 16 audio "codec";
 TEST_F(End2EndTest, LoopNoLossPcm16ExternalDecoder) {
-  Configure(transport::kVp8, transport::kPcm16, 32000, true, 1);
+  Configure(transport::kVp8, transport::kPcm16, 32000, 1);
   Create();
 
   const int kNumIterations = 10;
   for (int i = 0; i < kNumIterations; ++i) {
     FeedAudioFrames(1, true);
     RunTasks(kAudioFrameDurationMs);
     frame_receiver_->GetCodedAudioFrame(
         base::Bind(&TestReceiverAudioCallback::CheckCodedAudioFrame,
                    test_receiver_audio_callback_));
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(kNumIterations,
             test_receiver_audio_callback_->number_times_called());
 }
 
 // This tests our Opus audio codec without video.
 TEST_F(End2EndTest, LoopNoLossOpus) {
-  Configure(transport::kVp8, transport::kOpus, kDefaultAudioSamplingRate,
-            false, 1);
+  Configure(transport::kVp8, transport::kOpus, kDefaultAudioSamplingRate, 1);
   Create();
 
   const int kNumIterations = 300;
   for (int i = 0; i < kNumIterations; ++i) {
     // Opus introduces a tiny delay before the sinewave starts; so don't examine
     // the first frame.
     const bool examine_audio_data = i > 0;
     FeedAudioFrames(1, examine_audio_data);
     RunTasks(kAudioFrameDurationMs);
     RequestAudioFrames(1, examine_audio_data);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(kNumIterations,
             test_receiver_audio_callback_->number_times_called());
 }
 
 // This tests start sending audio and video at start-up time before the receiver
 // is ready; it sends 2 frames before the receiver comes online.
 //
 // Test disabled due to flakiness: It appears that the RTCP synchronization
 // sometimes kicks in, and sometimes doesn't.  When it does, there's a sharp
 // discontinuity in the timeline, throwing off the test expectations.  See TODOs
 // in audio_receiver.cc for likely cause(s) of this bug.
 // http://crbug.com/356942
 TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
-  Configure(transport::kVp8, transport::kPcm16, kDefaultAudioSamplingRate,
-            false, 1);
+  Configure(transport::kVp8, transport::kPcm16, kDefaultAudioSamplingRate, 1);
   Create();
 
   int video_start = kVideoStart;
   int audio_diff = kFrameTimerMs;
 
   sender_to_receiver_.SetSendPackets(false);
 
   const int test_delay_ms = 100;
 
   const int kNumVideoFramesBeforeReceiverStarted = 2;
@@ skipping 67 matching lines @@
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(num_audio_frames_requested,
             test_receiver_audio_callback_->number_times_called());
   EXPECT_EQ(10, test_receiver_video_callback_->number_times_called());
 }
 
 // This tests a network glitch lasting for 10 video frames.
 // Flaky. See crbug.com/351596.
 TEST_F(End2EndTest, DISABLED_GlitchWith3Buffers) {
-  Configure(transport::kVp8, transport::kOpus, kDefaultAudioSamplingRate,
-            false, 3);
+  Configure(transport::kVp8, transport::kOpus, kDefaultAudioSamplingRate, 3);
   video_sender_config_.rtp_config.max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
 
   int video_start = kVideoStart;
   base::TimeTicks capture_time;
   // Frames will rendered on completion until the render time stabilizes, i.e.
   // we got enough data.
   const int frames_before_glitch = 20;
   for (int i = 0; i < frames_before_glitch; ++i) {
@@ skipping 42 matching lines @@
       base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                  test_receiver_video_callback_));
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the receiver pipeline.
   EXPECT_EQ(frames_before_glitch + 1,
             test_receiver_video_callback_->number_times_called());
 }
 
 // Disabled due to flakiness and crashiness.  http://crbug.com/360951
 TEST_F(End2EndTest, DISABLED_DropEveryOtherFrame3Buffers) {
-  Configure(transport::kVp8, transport::kOpus, kDefaultAudioSamplingRate, false,
-            3);
+  Configure(transport::kVp8, transport::kOpus, kDefaultAudioSamplingRate, 3);
   video_sender_config_.rtp_config.max_delay_ms = 67;
   video_receiver_config_.rtp_max_delay_ms = 67;
   Create();
   sender_to_receiver_.DropAllPacketsBelongingToOddFrames();
 
   int video_start = kVideoStart;
   base::TimeTicks capture_time;
 
   int i = 0;
   for (; i < 20; ++i) {
@@ skipping 17 matching lines @@
     }
     RunTasks(kFrameTimerMs);
     video_start++;
   }
 
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(i / 2, test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoVideo) {
-  Configure(transport::kVp8, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kVp8, transport::kPcm16, 32000, 1);
 
   video_sender_config_.rtp_config.aes_iv_mask =
       ConvertFromBase16String("1234567890abcdeffedcba0987654321");
   video_sender_config_.rtp_config.aes_key =
       ConvertFromBase16String("deadbeefcafeb0b0b0b0cafedeadbeef");
 
   video_receiver_config_.aes_iv_mask =
       video_sender_config_.rtp_config.aes_iv_mask;
   video_receiver_config_.aes_key =
       video_sender_config_.rtp_config.aes_key;
@@ skipping 17 matching lines @@
     frame_receiver_->GetRawVideoFrame(
         base::Bind(&TestReceiverVideoCallback::CheckVideoFrame,
                    test_receiver_video_callback_));
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(frames_counter,
             test_receiver_video_callback_->number_times_called());
 }
 
 TEST_F(End2EndTest, CryptoAudio) {
-  Configure(transport::kVp8, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kVp8, transport::kPcm16, 32000, 1);
 
   audio_sender_config_.rtp_config.aes_iv_mask =
       ConvertFromBase16String("abcdeffedcba12345678900987654321");
     audio_sender_config_.rtp_config.aes_key =
       ConvertFromBase16String("deadbeefcafecafedeadbeefb0b0b0b0");
 
   audio_receiver_config_.aes_iv_mask =
       audio_sender_config_.rtp_config.aes_iv_mask;
   audio_receiver_config_.aes_key =
       audio_sender_config_.rtp_config.aes_key;
 
   Create();
 
   const int kNumIterations = 3;
   const int kNumAudioFramesPerIteration = 2;
   for (int i = 0; i < kNumIterations; ++i) {
     FeedAudioFrames(kNumAudioFramesPerIteration, true);
     RunTasks(kNumAudioFramesPerIteration * kAudioFrameDurationMs);
     RequestAudioFrames(kNumAudioFramesPerIteration, true);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(kNumIterations * kNumAudioFramesPerIteration,
             test_receiver_audio_callback_->number_times_called());
 }
 
 // Video test without packet loss - tests the logging aspects of the end2end,
 // but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, VideoLogging) {
-  Configure(transport::kVp8, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kVp8, transport::kPcm16, 32000, 1);
   Create();
 
   int video_start = kVideoStart;
   const int num_frames = 5;
   for (int i = 0; i < num_frames; ++i) {
     base::TimeTicks capture_time = testing_clock_sender_->NowTicks();
     test_receiver_video_callback_->AddExpectedResult(
         video_start,
         video_sender_config_.width,
         video_sender_config_.height,
@@ skipping 103 matching lines @@
 
     // Verify that there were no other events logged with respect to this
     // packet. (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_packet, expected_event_count_for_packet);
   }
 }
 
 // Audio test without packet loss - tests the logging aspects of the end2end,
 // but is basically equivalent to LoopNoLossPcm16.
 TEST_F(End2EndTest, AudioLogging) {
-  Configure(transport::kVp8, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kVp8, transport::kPcm16, 32000, 1);
   Create();
 
   int audio_diff = kFrameTimerMs;
   const int kNumVideoFrames = 10;
   int num_audio_frames_requested = 0;
   for (int i = 0; i < kNumVideoFrames; ++i) {
     const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
     audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
     FeedAudioFrames(num_audio_frames, true);
@@ skipping 57 matching lines @@
     EXPECT_GT(map_it->second.counter[FRAME_ACK_SENT], 0);
     expected_event_count_for_frame += map_it->second.counter[FRAME_ACK_SENT];
 
     // Verify that there were no other events logged with respect to this frame.
     // (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_frame, expected_event_count_for_frame);
   }
 }
 
 TEST_F(End2EndTest, BasicFakeSoftwareVideo) {
-  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, 1);
   Create();
   StartBasicPlayer();
   SetReceiverSkew(1.0, base::TimeDelta::FromMilliseconds(1));
 
   // Expect very smooth playout when there is no clock skew.
   SetExpectedVideoPlayoutSmoothness(
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 99 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 101 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 100);
 
   int frames_counter = 0;
   for (; frames_counter < 1000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(1000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, ReceiverClockFast) {
-  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, 1);
   Create();
   StartBasicPlayer();
   SetReceiverSkew(2.0, base::TimeDelta::FromMicroseconds(1234567));
 
   int frames_counter = 0;
   for (; frames_counter < 10000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(10000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, ReceiverClockSlow) {
-  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, 1);
   Create();
   StartBasicPlayer();
   SetReceiverSkew(0.5, base::TimeDelta::FromMicroseconds(-765432));
 
   int frames_counter = 0;
   for (; frames_counter < 10000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(10000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, SmoothPlayoutWithFivePercentClockRateSkew) {
-  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, 1);
   Create();
   StartBasicPlayer();
   SetReceiverSkew(1.05, base::TimeDelta::FromMilliseconds(-42));
 
   // Expect smooth playout when there is 5% skew.
   SetExpectedVideoPlayoutSmoothness(
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 90 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 110 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 10);
 
   int frames_counter = 0;
   for (; frames_counter < 10000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(10000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, EvilNetwork) {
-  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
+  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, 1);
   receiver_to_sender_.SetPacketPipe(test::EvilNetwork().Pass());
   sender_to_receiver_.SetPacketPipe(test::EvilNetwork().Pass());
   Create();
   StartBasicPlayer();
 
   int frames_counter = 0;
   for (; frames_counter < 10000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   base::TimeTicks test_end = testing_clock_receiver_->NowTicks();
   RunTasks(100 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_GT(video_ticks_.size(), 100ul);
   EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000);
 }
 
 // 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