VideoProcessorIntegrationTest: make it runnable on a task queue.

webrtc/modules/video_coding/codecs/test/videoprocessor.h

 /*
  *  Copyright (c) 2012 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.
  */
 
 #ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_
 #define WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_
 
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/video/video_frame.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/video_coding/codecs/test/packet_manipulator.h"
 #include "webrtc/modules/video_coding/codecs/test/stats.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/ivf_file_writer.h"
@@ skipping 82 matching lines @@
   // The codec settings to use for the test (target bitrate, video size,
   // framerate and so on). This struct should be filled in using the
   // VideoCodingModule::Codec() method.
   webrtc::VideoCodec codec_settings;
 
   // If printing of information to stdout shall be performed during processing.
   bool verbose = true;
 
   // If HW or SW codec should be used.
   bool hw_codec = false;
-
-  // In batch mode, the VideoProcessor is fed all the frames for processing
-  // before any metrics are calculated. This is useful for pipelining HW codecs,
-  // for which some calculated metrics otherwise would be incorrect. The
-  // downside with batch mode is that mid-test rate allocation is not supported.
-  bool batch_mode = false;
 };
 
 // Handles encoding/decoding of video using the VideoEncoder/VideoDecoder
 // interfaces. This is done in a sequential manner in order to be able to
 // measure times properly.
 // The class processes a frame at the time for the configured input file.
 // It maintains state of where in the source input file the processing is at.
 //
 // Regarding packet loss: Note that keyframes are excluded (first or all
 // depending on the ExcludeFrameTypes setting). This is because if key frames
@@ skipping 26 matching lines @@
   // Tears down callbacks and releases the encoder and decoder.
   void Release();
 
   // Processes a single frame. The frames must be processed in order, and the
   // VideoProcessor must be initialized first.
   void ProcessFrame(int frame_number);
 
   // Updates the encoder with target rates. Must be called at least once.
   void SetRates(int bitrate_kbps, int framerate_fps);
 
-
   // TODO(brandtr): Get rid of these functions by moving the corresponding QP
   // fields to the Stats object.
   int GetQpFromEncoder(int frame_number) const;
   int GetQpFromBitstream(int frame_number) const;
 
+  // Returns the number of dropped frames.
+  std::vector<int> NumberDroppedFramesPerRateUpdate() const;
 
-  // Return the number of dropped frames.
-  int NumberDroppedFrames();
+  // Returns the number of spatial resizes.
+  std::vector<int> NumberSpatialResizesPerRateUpdate() const;
 
-  // Return the number of spatial resizes.
-  int NumberSpatialResizes();
+  int LastDecodedFrameNumber() const;
 
  private:
   // Container that holds per-frame information that needs to be stored between
   // calls to Encode and Decode, as well as the corresponding callbacks. It is
   // not directly used for statistics -- for that, test::FrameStatistic is used.
   // TODO(brandtr): Get rid of this struct and use the Stats class instead.
   struct FrameInfo {
     int64_t encode_start_ns = 0;
     int64_t decode_start_ns = 0;
     int qp_encoder = 0;
@@ skipping 99 matching lines @@
   };
 
   // Invoked by the callback adapter when a frame has completed encoding.
   void FrameEncoded(webrtc::VideoCodecType codec,
                     const webrtc::EncodedImage& encodedImage,
                     const webrtc::RTPFragmentationHeader* fragmentation);
 
   // Invoked by the callback adapter when a frame has completed decoding.
   void FrameDecoded(const webrtc::VideoFrame& image);
 
-  // Use the frame number as the basis for timestamp to identify frames. Let the
-  // first timestamp be non-zero, to not make the IvfFileWriter believe that we
-  // want to use capture timestamps in the IVF files.
-  uint32_t FrameNumberToTimestamp(int frame_number) const;
-  int TimestampToFrameNumber(uint32_t timestamp) const;
-
   bool initialized_ GUARDED_BY(sequence_checker_);
-
   TestConfig config_ GUARDED_BY(sequence_checker_);
 
   webrtc::VideoEncoder* const encoder_;
   webrtc::VideoDecoder* const decoder_;
   const std::unique_ptr<VideoBitrateAllocator> bitrate_allocator_;
 
   // Adapters for the codec callbacks.
   VideoProcessorEncodeCompleteCallback encode_callback_;
   VideoProcessorDecodeCompleteCallback decode_callback_;
 
@@ skipping 12 matching lines @@
   IvfFileWriter* const encoded_frame_writer_;
   FrameWriter* const decoded_frame_writer_;
 
   // Frame metadata for all frames that have been added through a call to
   // ProcessFrames(). We need to store this metadata over the course of the
   // test run, to support pipelining HW codecs.
   std::vector<FrameInfo> frame_infos_ GUARDED_BY(sequence_checker_);
   int last_encoded_frame_num_ GUARDED_BY(sequence_checker_);
   int last_decoded_frame_num_ GUARDED_BY(sequence_checker_);
 
+  // Store an RTP timestamp -> frame number map, since the timestamps are
+  // based off of the frame rate, which can change mid-test.
+  std::map<uint32_t, int> rtp_timestamp_to_frame_num_
+      GUARDED_BY(sequence_checker_);
+
   // Keep track of if we have excluded the first key frame from packet loss.
   bool first_key_frame_has_been_excluded_ GUARDED_BY(sequence_checker_);
 
   // Keep track of the last successfully decoded frame, since we write that
   // frame to disk when decoding fails.
   rtc::Buffer last_decoded_frame_buffer_ GUARDED_BY(sequence_checker_);
 
   // Statistics.
   Stats* stats_;
-  int num_dropped_frames_ GUARDED_BY(sequence_checker_);
-  int num_spatial_resizes_ GUARDED_BY(sequence_checker_);
+  std::vector<int> num_dropped_frames_ GUARDED_BY(sequence_checker_);
+  std::vector<int> num_spatial_resizes_ GUARDED_BY(sequence_checker_);
+  int rate_update_index_ GUARDED_BY(sequence_checker_);
 
   rtc::SequencedTaskChecker sequence_checker_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoProcessor);
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_