Delete EncodedFrameObserver::OnEncodeTiming.

This callback was used only by the PrintSamplesToFile feature of
video_quality_test, which looks like it has been broken for some time
(due to mixup of capture time and ntp time).

Bug: webrtc:8504
Change-Id: I7d2b55405caeffda582ae0d6fb0e7dfdfce4c5a9
Reviewed-on: https://webrtc-review.googlesource.com/31420
Commit-Queue: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21211}

common_video/include/frame_callback.h

@@ -49,7 +49,6 @@ struct EncodedFrame {
 class EncodedFrameObserver {
  public:
   virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) = 0;
-  virtual void OnEncodeTiming(int64_t capture_ntp_ms, int encode_duration_ms) {}
 
  protected:
   virtual ~EncodedFrameObserver() {}

video/encoder_rtcp_feedback_unittest.cc

@@ -29,7 +29,6 @@ class MockVideoStreamEncoder : public VideoStreamEncoder {
                            VideoSendStream::Config::EncoderSettings("fake", 0,
                                                                     nullptr),
                            nullptr,
-                           nullptr,
                            std::unique_ptr<OveruseFrameDetector>()) {}
   ~MockVideoStreamEncoder() { Stop(); }
 

video/overuse_frame_detector.cc

@@ -20,7 +20,6 @@
 #include <utility>
 
 #include "api/video/video_frame.h"
-#include "common_video/include/frame_callback.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/exp_filter.h"
@@ -71,13 +70,11 @@ const auto kScaleReasonCpu = AdaptationObserverInterface::AdaptReason::kCpu;
 // captured frames).
 class SendProcessingUsage : public OveruseFrameDetector::ProcessingUsage {
  public:
-  explicit SendProcessingUsage(const CpuOveruseOptions& options,
-                               EncodedFrameObserver* encoder_timing)
+  explicit SendProcessingUsage(const CpuOveruseOptions& options)
       : kWeightFactorFrameDiff(0.998f),
         kWeightFactorProcessing(0.995f),
         kInitialSampleDiffMs(40.0f),
         options_(options),
-        encoder_timing_(encoder_timing),
         count_(0),
         last_processed_capture_time_us_(-1),
         max_sample_diff_ms_(kDefaultSampleDiffMs * kMaxSampleDiffMarginFactor),
@@ -142,12 +139,7 @@ class SendProcessingUsage : public OveruseFrameDetector::ProcessingUsage {
       if (timing.last_send_us != -1) {
         encode_duration_us.emplace(
             static_cast<int>(timing.last_send_us - timing.capture_us));
-        if (encoder_timing_) {
-          // TODO(nisse): Update encoder_timing_ to also use us units.
-          encoder_timing_->OnEncodeTiming(
-              timing.capture_time_us / rtc::kNumMicrosecsPerMillisec,
-              *encode_duration_us / rtc::kNumMicrosecsPerMillisec);
-        }
+
         if (last_processed_capture_time_us_ != -1) {
           int64_t diff_us = timing.capture_us - last_processed_capture_time_us_;
           AddSample(1e-3 * (*encode_duration_us), 1e-3 * diff_us);
@@ -211,7 +203,6 @@ class SendProcessingUsage : public OveruseFrameDetector::ProcessingUsage {
   const float kInitialSampleDiffMs;
 
   const CpuOveruseOptions options_;
-  EncodedFrameObserver* const encoder_timing_;
   std::list<FrameTiming> frame_timing_;
   uint64_t count_;
   int64_t last_processed_capture_time_us_;
@@ -224,11 +215,10 @@ class SendProcessingUsage : public OveruseFrameDetector::ProcessingUsage {
 class OverdoseInjector : public SendProcessingUsage {
  public:
   OverdoseInjector(const CpuOveruseOptions& options,
-                   EncodedFrameObserver* encoder_timing,
                    int64_t normal_period_ms,
                    int64_t overuse_period_ms,
                    int64_t underuse_period_ms)
-      : SendProcessingUsage(options, encoder_timing),
+      : SendProcessingUsage(options),
         normal_period_ms_(normal_period_ms),
         overuse_period_ms_(overuse_period_ms),
         underuse_period_ms_(underuse_period_ms),
@@ -350,8 +340,7 @@ CpuOveruseOptions::CpuOveruseOptions()
 
 std::unique_ptr<OveruseFrameDetector::ProcessingUsage>
 OveruseFrameDetector::CreateProcessingUsage(
-    const CpuOveruseOptions& options,
-    EncodedFrameObserver* encoder_timing) {
+    const CpuOveruseOptions& options) {
   std::unique_ptr<ProcessingUsage> instance;
   std::string toggling_interval =
       field_trial::FindFullName("WebRTC-ForceSimulatedOveruseIntervalMs");
@@ -364,7 +353,7 @@ OveruseFrameDetector::CreateProcessingUsage(
       if (normal_period_ms > 0 && overuse_period_ms > 0 &&
           underuse_period_ms > 0) {
         instance = rtc::MakeUnique<OverdoseInjector>(
-            options, encoder_timing, normal_period_ms, overuse_period_ms,
+            options, normal_period_ms, overuse_period_ms,
             underuse_period_ms);
       } else {
         RTC_LOG(LS_WARNING)
@@ -380,7 +369,7 @@ OveruseFrameDetector::CreateProcessingUsage(
 
   if (!instance) {
     // No valid overuse simulation parameters set, use normal usage class.
-    instance = rtc::MakeUnique<SendProcessingUsage>(options, encoder_timing);
+    instance = rtc::MakeUnique<SendProcessingUsage>(options);
   }
 
   return instance;
@@ -419,7 +408,6 @@ class OveruseFrameDetector::CheckOveruseTask : public rtc::QueuedTask {
 OveruseFrameDetector::OveruseFrameDetector(
     const CpuOveruseOptions& options,
     AdaptationObserverInterface* observer,
-    EncodedFrameObserver* encoder_timing,
     CpuOveruseMetricsObserver* metrics_observer)
     : check_overuse_task_(nullptr),
       options_(options),
@@ -436,7 +424,7 @@ OveruseFrameDetector::OveruseFrameDetector(
       last_rampup_time_ms_(-1),
       in_quick_rampup_(false),
       current_rampup_delay_ms_(kStandardRampUpDelayMs),
-      usage_(CreateProcessingUsage(options, encoder_timing)) {
+      usage_(CreateProcessingUsage(options)) {
   task_checker_.Detach();
 }
 

video/overuse_frame_detector.h

@@ -24,7 +24,6 @@
 
 namespace webrtc {
 
-class EncodedFrameObserver;
 class VideoFrame;
 
 struct CpuOveruseOptions {
@@ -66,7 +65,6 @@ class OveruseFrameDetector {
  public:
   OveruseFrameDetector(const CpuOveruseOptions& options,
                        AdaptationObserverInterface* overuse_observer,
-                       EncodedFrameObserver* encoder_timing_,
                        CpuOveruseMetricsObserver* metrics_observer);
   virtual ~OveruseFrameDetector();
 
@@ -122,8 +120,7 @@ class OveruseFrameDetector {
   void ResetAll(int num_pixels);
 
   static std::unique_ptr<ProcessingUsage> CreateProcessingUsage(
-      const CpuOveruseOptions& options,
-      EncodedFrameObserver* encoder_timing);
+      const CpuOveruseOptions& options);
 
   rtc::SequencedTaskChecker task_checker_;
   // Owned by the task queue from where StartCheckForOveruse is called.

video/overuse_frame_detector_unittest.cc

@@ -57,11 +57,9 @@ class OveruseFrameDetectorUnderTest : public OveruseFrameDetector {
  public:
   OveruseFrameDetectorUnderTest(const CpuOveruseOptions& options,
                                 AdaptationObserverInterface* overuse_observer,
-                                EncodedFrameObserver* encoder_timing,
                                 CpuOveruseMetricsObserver* metrics_observer)
       : OveruseFrameDetector(options,
                              overuse_observer,
-                             encoder_timing,
                              metrics_observer) {}
   ~OveruseFrameDetectorUnderTest() {}
 
@@ -79,7 +77,7 @@ class OveruseFrameDetectorTest : public ::testing::Test,
 
   void ReinitializeOveruseDetector() {
     overuse_detector_.reset(new OveruseFrameDetectorUnderTest(
-        options_, observer_.get(), nullptr, this));
+        options_, observer_.get(), this));
   }
 
   void OnEncodedFrameTimeMeasured(int encode_time_ms,
@@ -182,7 +180,7 @@ TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
 
 TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithNoObserver) {
   overuse_detector_.reset(new OveruseFrameDetectorUnderTest(
-      options_, nullptr, nullptr, this));
+      options_, nullptr, this));
   EXPECT_CALL(*(observer_.get()), AdaptDown(reason_)).Times(0);
   TriggerOveruse(options_.high_threshold_consecutive_count);
   EXPECT_CALL(*(observer_.get()), AdaptUp(reason_)).Times(0);
@@ -202,7 +200,7 @@ TEST_F(OveruseFrameDetectorTest, TriggerUnderuseWithMinProcessCount) {
   options_.min_process_count = 1;
   CpuOveruseObserverImpl overuse_observer;
   overuse_detector_.reset(new OveruseFrameDetectorUnderTest(
-      options_, &overuse_observer, nullptr, this));
+      options_, &overuse_observer, this));
   InsertAndSendFramesWithInterval(
       1200, kFrameIntervalUs, kWidth, kHeight, kProcessTimeUs);
   overuse_detector_->CheckForOveruse();

video/video_quality_test.cc

@@ -318,11 +318,6 @@ class VideoAnalyzer : public PacketReceiver,
     return receiver_->DeliverPacket(media_type, std::move(packet), packet_time);
   }
 
-  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_encoded_timestamp_) {
@@ -592,9 +587,6 @@ class VideoAnalyzer : public PacketReceiver,
    public:
     explicit OnEncodeTimingProxy(VideoAnalyzer* parent) : parent_(parent) {}
 
-    void OnEncodeTiming(int64_t ntp_time_ms, int encode_time_ms) override {
-      parent_->MeasuredEncodeTiming(ntp_time_ms, encode_time_ms);
-    }
     void EncodedFrameCallback(const EncodedFrame& frame) override {
       parent_->PostEncodeFrameCallback(frame);
     }
@@ -946,27 +938,12 @@ class VideoAnalyzer : public PacketReceiver,
             "psnr "
             "ssim "
             "encode_time_ms\n");
-    int missing_encode_time_samples = 0;
     for (const Sample& sample : samples_) {
-      auto it = samples_encode_time_ms_.find(sample.input_time_ms);
-      int encode_time_ms;
-      if (it != samples_encode_time_ms_.end()) {
-        encode_time_ms = it->second;
-      } else {
-        ++missing_encode_time_samples;
-        encode_time_ms = -1;
-      }
       fprintf(out, "%d %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRIuS
-                   " %lf %lf %d\n",
+                   " %lf %lf\n",
               sample.dropped, sample.input_time_ms, sample.send_time_ms,
               sample.recv_time_ms, sample.render_time_ms,
-              sample.encoded_frame_size, sample.psnr, sample.ssim,
-              encode_time_ms);
-    }
-    if (missing_encode_time_samples) {
-      fprintf(stderr,
-              "Warning: Missing encode_time_ms samples for %d frame(s).\n",
-              missing_encode_time_samples);
+              sample.encoded_frame_size, sample.psnr, sample.ssim);
     }
   }
 
@@ -1061,8 +1038,6 @@ class VideoAnalyzer : public PacketReceiver,
   PreEncodeProxy pre_encode_proxy_;
   OnEncodeTimingProxy encode_timing_proxy_;
   std::vector<Sample> samples_ RTC_GUARDED_BY(comparison_lock_);
-  std::map<int64_t, int> samples_encode_time_ms_
-      RTC_GUARDED_BY(comparison_lock_);
   test::Statistics sender_time_ RTC_GUARDED_BY(comparison_lock_);
   test::Statistics receiver_time_ RTC_GUARDED_BY(comparison_lock_);
   test::Statistics psnr_ RTC_GUARDED_BY(comparison_lock_);

video/video_send_stream.cc

@@ -567,7 +567,6 @@ VideoSendStream::VideoSendStream(
       new VideoStreamEncoder(num_cpu_cores, &stats_proxy_,
                              config_.encoder_settings,
                              config_.pre_encode_callback,
-                             config_.post_encode_callback,
                              std::unique_ptr<OveruseFrameDetector>()));
   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(new ConstructionTask(
       &send_stream_, &thread_sync_event_, &stats_proxy_,

video/video_stream_encoder.cc

@@ -388,7 +388,6 @@ VideoStreamEncoder::VideoStreamEncoder(
     SendStatisticsProxy* stats_proxy,
     const VideoSendStream::Config::EncoderSettings& settings,
     rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback,
-    EncodedFrameObserver* encoder_timing,
     std::unique_ptr<OveruseFrameDetector> overuse_detector)
     : shutdown_event_(true /* manual_reset */, false),
       number_of_cores_(number_of_cores),
@@ -404,7 +403,6 @@ VideoStreamEncoder::VideoStreamEncoder(
               : new OveruseFrameDetector(
                     GetCpuOveruseOptions(settings.full_overuse_time),
                     this,
-                    encoder_timing,
                     stats_proxy)),
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),

video/video_stream_encoder.h

@@ -75,7 +75,6 @@ class VideoStreamEncoder : public rtc::VideoSinkInterface<VideoFrame>,
                      SendStatisticsProxy* stats_proxy,
                      const VideoSendStream::Config::EncoderSettings& settings,
                      rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback,
-                     EncodedFrameObserver* encoder_timing,
                      std::unique_ptr<OveruseFrameDetector> overuse_detector);
   ~VideoStreamEncoder();
 

video/video_stream_encoder_unittest.cc

@@ -67,11 +67,9 @@ class CpuOveruseDetectorProxy : public OveruseFrameDetector {
  public:
   CpuOveruseDetectorProxy(const CpuOveruseOptions& options,
                           AdaptationObserverInterface* overuse_observer,
-                          EncodedFrameObserver* encoder_timing_,
                           CpuOveruseMetricsObserver* metrics_observer)
       : OveruseFrameDetector(options,
                              overuse_observer,
-                             encoder_timing_,
                              metrics_observer),
         last_target_framerate_fps_(-1) {}
   virtual ~CpuOveruseDetectorProxy() {}
@@ -101,12 +99,10 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
             stats_proxy,
             settings,
             nullptr /* pre_encode_callback */,
-            nullptr /* encoder_timing */,
             std::unique_ptr<OveruseFrameDetector>(
                 overuse_detector_proxy_ = new CpuOveruseDetectorProxy(
                     GetCpuOveruseOptions(settings.full_overuse_time),
                     this,
-                    nullptr,
                     stats_proxy))) {}
 
   void PostTaskAndWait(bool down, AdaptReason reason) {