Cast: First stab at implementing adaptive latency

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 456 matching lines @@
     cast_environment_sender_->Logging()->AddRawEventSubscriber(
         &event_subscriber_sender_);
   }
 
   void Configure(Codec video_codec,
                  Codec audio_codec,
                  int audio_sampling_frequency,
                  int max_number_of_video_buffers_used) {
     audio_sender_config_.ssrc = 1;
     audio_sender_config_.incoming_feedback_ssrc = 2;
-    audio_sender_config_.target_playout_delay =
+    audio_sender_config_.max_playout_delay =
         base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs);
     audio_sender_config_.rtp_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_.ssrc;
     audio_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs;
     audio_receiver_config_.rtp_payload_type =
         audio_sender_config_.rtp_payload_type;
     audio_receiver_config_.frequency = audio_sender_config_.frequency;
     audio_receiver_config_.channels = kAudioChannels;
     audio_receiver_config_.max_frame_rate = 100;
     audio_receiver_config_.codec = audio_sender_config_.codec;
 
     test_receiver_audio_callback_->SetExpectedSamplingFrequency(
         audio_receiver_config_.frequency);
 
     video_sender_config_.ssrc = 3;
     video_sender_config_.incoming_feedback_ssrc = 4;
-    video_sender_config_.target_playout_delay =
+    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;
@@ skipping 475 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());
 }
 
 TEST_F(End2EndTest, DropEveryOtherFrame3Buffers) {
   Configure(CODEC_VIDEO_VP8, CODEC_AUDIO_OPUS, kDefaultAudioSamplingRate, 3);
   int target_delay = 300;
-  video_sender_config_.target_playout_delay =
+  video_sender_config_.max_playout_delay =
       base::TimeDelta::FromMilliseconds(target_delay);
-  audio_sender_config_.target_playout_delay =
+  audio_sender_config_.max_playout_delay =
       base::TimeDelta::FromMilliseconds(target_delay);
   video_receiver_config_.rtp_max_delay_ms = target_delay;
   Create();
   sender_to_receiver_.DropAllPacketsBelongingToOddFrames();
 
   int video_start = kVideoStart;
   base::TimeTicks capture_time;
 
   int i = 0;
   for (; i < 20; ++i) {
@@ skipping 418 matching lines @@
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(100 * kFrameTimerMs + 1);  // Empty the pipeline.
 
   EXPECT_EQ(10000ul, video_ticks_.size());
 }
 
 TEST_F(End2EndTest, TestSetPlayoutDelay) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1);
+  video_sender_config_.min_playout_delay =
+      video_sender_config_.max_playout_delay;
+  audio_sender_config_.min_playout_delay =
+      audio_sender_config_.max_playout_delay;
+  video_sender_config_.max_playout_delay = base::TimeDelta::FromSeconds(1);
+  audio_sender_config_.max_playout_delay = base::TimeDelta::FromSeconds(1);
   Create();
   StartBasicPlayer();
   const int kNewDelay = 600;
 
   int frames_counter = 0;
   for (; frames_counter < 200; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   cast_sender_->SetTargetPlayoutDelay(
@@ skipping 17 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