Drop frames until specified bitrate is achieved.

webrtc/video/video_quality_test.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/video/video_quality_test.h"
@@ skipping 223 matching lines @@
   }
 
   void MeasuredEncodeTiming(int64_t ntp_time_ms, int encode_time_ms) {
     rtc::CritScope crit(&comparison_lock_);
     samples_encode_time_ms_[ntp_time_ms] = encode_time_ms;
   }
 
   void PreEncodeOnFrame(const VideoFrame& video_frame) {
     rtc::CritScope lock(&crit_);
     if (!first_send_timestamp_ && rtp_timestamp_delta_ == 0) {
+      printf("pre-encode: setting first_send_timestamp\n");
       while (frames_.front().timestamp() != video_frame.timestamp()) {
         ++dropped_frames_before_first_encode_;
         frames_.pop_front();
         RTC_CHECK(!frames_.empty());
       }
       first_send_timestamp_ = rtc::Optional<uint32_t>(video_frame.timestamp());
     }
   }
 
   bool SendRtp(const uint8_t* packet,
                size_t length,
                const PacketOptions& options) override {
     RtpUtility::RtpHeaderParser parser(packet, length);
     RTPHeader header;
     parser.Parse(&header);
 
     int64_t current_time =
         Clock::GetRealTimeClock()->CurrentNtpInMilliseconds();
     bool result = transport_->SendRtp(packet, length, options);
     {
       rtc::CritScope lock(&crit_);
 
       if (rtp_timestamp_delta_ == 0) {
+        printf("Now setting delta\n");
         rtp_timestamp_delta_ = header.timestamp - *first_send_timestamp_;
         first_send_timestamp_ = rtc::Optional<uint32_t>();
       }
       if (!IsFlexfec(header.payloadType)) {
         // Ignore FlexFEC timestamps, to avoid collisions with media timestamps.
         // (FlexFEC and media are sent on different SSRCs, which have different
         // timestamps spaces.)
         int64_t timestamp =
             wrap_handler_.Unwrap(header.timestamp - rtp_timestamp_delta_);
         send_times_[timestamp] = current_time;
@@ skipping 23 matching lines @@
 
     rtc::CritScope lock(&crit_);
     int64_t send_timestamp =
         wrap_handler_.Unwrap(video_frame.timestamp() - rtp_timestamp_delta_);
 
     while (wrap_handler_.Unwrap(frames_.front().timestamp()) < send_timestamp) {
       if (!last_rendered_frame_) {
         // No previous frame rendered, this one was dropped after sending but
         // before rendering.
         ++dropped_frames_before_rendering_;
-        frames_.pop_front();
-        RTC_CHECK(!frames_.empty());
-        continue;
+      } else {
+        AddFrameComparison(frames_.front(), *last_rendered_frame_, true,
+                           render_time_ms);
       }
-      AddFrameComparison(frames_.front(), *last_rendered_frame_, true,
-                         render_time_ms);
       frames_.pop_front();
       RTC_DCHECK(!frames_.empty());
     }
 
+    printf("send_timestamp: %ld\n", send_timestamp);
+    printf("frame_timestamp: %ld\n",
+           wrap_handler_.Unwrap(frames_.front().timestamp()));
+
     VideoFrame reference_frame = frames_.front();
     frames_.pop_front();
     int64_t reference_timestamp =
         wrap_handler_.Unwrap(reference_frame.timestamp());
     if (send_timestamp == reference_timestamp - 1) {
       // TODO(ivica): Make this work for > 2 streams.
       // Look at RTPSender::BuildRTPHeader.
       ++send_timestamp;
     }
+    printf("diff: %ld\n", reference_timestamp - send_timestamp);
     ASSERT_EQ(reference_timestamp, send_timestamp);
 
     AddFrameComparison(reference_frame, video_frame, false, render_time_ms);
 
     last_rendered_frame_ = rtc::Optional<VideoFrame>(video_frame);
   }
 
   void Wait() {
     // Frame comparisons can be very expensive. Wait for test to be done, but
     // at time-out check if frames_processed is going up. If so, give it more
@@ skipping 810 matching lines @@
         .rtp.ulpfec.red_rtx_payload_type =
         video_send_config_.rtp.ulpfec.red_rtx_payload_type;
   }
 }
 
 void VideoQualityTest::SetupScreenshare() {
   RTC_CHECK(params_.screenshare.enabled);
 
   // Fill out codec settings.
   video_encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
+  degradation_preference_ =
+      VideoSendStream::DegradationPreference::kMaintainResolution;
   if (params_.video.codec == "VP8") {
     VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
     vp8_settings.denoisingOn = false;
     vp8_settings.frameDroppingOn = false;
     vp8_settings.numberOfTemporalLayers =
         static_cast<unsigned char>(params_.video.num_temporal_layers);
     video_encoder_config_.encoder_specific_settings = new rtc::RefCountedObject<
         VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
   } else if (params_.video.codec == "VP9") {
     VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
@@ skipping 133 matching lines @@
     config.pre_decode_callback = &analyzer;
   RTC_DCHECK(!video_send_config_.post_encode_callback);
   video_send_config_.post_encode_callback = analyzer.encode_timing_proxy();
 
   if (params_.screenshare.enabled)
     SetupScreenshare();
 
   CreateFlexfecStreams();
   CreateVideoStreams();
   analyzer.SetSendStream(video_send_stream_);
-  video_send_stream_->SetSource(
-      analyzer.OutputInterface(),
-      VideoSendStream::DegradationPreference::kBalanced);
+  video_send_stream_->SetSource(analyzer.OutputInterface(),
+                                degradation_preference_);
 
   CreateCapturer();
   rtc::VideoSinkWants wants;
   video_capturer_->AddOrUpdateSink(analyzer.InputInterface(), wants);
 
   StartEncodedFrameLogs(video_send_stream_);
   StartEncodedFrameLogs(video_receive_streams_[0]);
   video_send_stream_->Start();
   for (VideoReceiveStream* receive_stream : video_receive_streams_)
     receive_stream->Start();
@@ skipping 121 matching lines @@
     video_send_stream_ = call->CreateVideoSendStream(
         video_send_config_.Copy(), video_encoder_config_.Copy());
     if (params_.video.flexfec) {
       RTC_DCHECK(!flexfec_receive_configs_.empty());
       flexfec_receive_stream =
           call->CreateFlexfecReceiveStream(flexfec_receive_configs_[0]);
     }
     video_receive_stream = call->CreateVideoReceiveStream(
         video_receive_configs_[stream_id].Copy());
     CreateCapturer();
-    video_send_stream_->SetSource(
-        video_capturer_.get(),
-        VideoSendStream::DegradationPreference::kBalanced);
+    video_send_stream_->SetSource(video_capturer_.get(),
+                                  degradation_preference_);
   }
 
   AudioReceiveStream* audio_receive_stream = nullptr;
   if (params_.audio.enabled) {
     SetupAudio(voe.send_channel_id, voe.receive_channel_id, call.get(),
                &transport, &audio_receive_stream);
   }
 
   StartEncodedFrameLogs(video_receive_stream);
   StartEncodedFrameLogs(video_send_stream_);
@@ skipping 68 matching lines @@
     std::ostringstream str;
     str << receive_logs_++;
     std::string path =
         params_.video.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
     stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
                                         10000000);
   }
 }
 
 }  // namespace webrtc