kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 1 | /* |
marpan@webrtc.org | f4c2de9 | 2012-06-05 21:07:28 +0000 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
kjellander@webrtc.org | 5b97b12 | 2011-12-08 07:42:18 +0000 | [diff] [blame] | 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #ifndef MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_ |
| 12 | #define MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_ |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 13 | |
brandtr | b57f426 | 2017-08-30 06:29:51 -0700 | [diff] [blame] | 14 | #include <map> |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 15 | #include <memory> |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 16 | #include <string> |
brandtr | 17b958c | 2017-03-07 01:41:43 -0800 | [diff] [blame] | 17 | #include <vector> |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 18 | |
Kári Tristan Helgason | 169005d | 2018-05-22 13:34:14 +0200 | [diff] [blame] | 19 | #include "api/test/videocodec_test_fixture.h" |
| 20 | #include "api/test/videocodec_test_stats.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 21 | #include "api/video/video_frame.h" |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 22 | #include "common_video/include/video_bitrate_allocator.h" |
Kári Tristan Helgason | 169005d | 2018-05-22 13:34:14 +0200 | [diff] [blame] | 23 | #include "modules/video_coding/include/video_codec_interface.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "modules/video_coding/utility/ivf_file_writer.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 25 | #include "rtc_base/buffer.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 26 | #include "rtc_base/constructormagic.h" |
| 27 | #include "rtc_base/sequenced_task_checker.h" |
| 28 | #include "rtc_base/task_queue.h" |
| 29 | #include "test/testsupport/frame_reader.h" |
| 30 | #include "test/testsupport/frame_writer.h" |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 31 | |
| 32 | namespace webrtc { |
| 33 | namespace test { |
| 34 | |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 35 | // Handles encoding/decoding of video using the VideoEncoder/VideoDecoder |
| 36 | // interfaces. This is done in a sequential manner in order to be able to |
| 37 | // measure times properly. |
| 38 | // The class processes a frame at the time for the configured input file. |
| 39 | // It maintains state of where in the source input file the processing is at. |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 40 | class VideoProcessor { |
| 41 | public: |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 42 | using VideoDecoderList = std::vector<std::unique_ptr<VideoDecoder>>; |
| 43 | using IvfFileWriterList = std::vector<std::unique_ptr<IvfFileWriter>>; |
| 44 | using FrameWriterList = std::vector<std::unique_ptr<FrameWriter>>; |
| 45 | |
brandtr | c409552 | 2017-08-07 08:12:33 -0700 | [diff] [blame] | 46 | VideoProcessor(webrtc::VideoEncoder* encoder, |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 47 | VideoDecoderList* decoders, |
| 48 | FrameReader* input_frame_reader, |
Kári Tristan Helgason | 169005d | 2018-05-22 13:34:14 +0200 | [diff] [blame] | 49 | const VideoCodecTestFixture::Config& config, |
| 50 | VideoCodecTestStats* stats, |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 51 | IvfFileWriterList* encoded_frame_writers, |
| 52 | FrameWriterList* decoded_frame_writers); |
brandtr | c409552 | 2017-08-07 08:12:33 -0700 | [diff] [blame] | 53 | ~VideoProcessor(); |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 54 | |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 55 | // Reads a frame and sends it to the encoder. When the encode callback |
| 56 | // is received, the encoded frame is buffered. After encoding is finished |
| 57 | // buffered frame is sent to decoder. Quality evaluation is done in |
| 58 | // the decode callback. |
brandtr | 8935d97 | 2017-09-06 01:53:22 -0700 | [diff] [blame] | 59 | void ProcessFrame(); |
marpan@webrtc.org | f4c2de9 | 2012-06-05 21:07:28 +0000 | [diff] [blame] | 60 | |
brandtr | bdd555c | 2017-08-21 01:34:04 -0700 | [diff] [blame] | 61 | // Updates the encoder with target rates. Must be called at least once. |
Sergey Silkin | 3be2a55 | 2018-01-17 15:11:44 +0100 | [diff] [blame] | 62 | void SetRates(size_t bitrate_kbps, size_t framerate_fps); |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 63 | |
| 64 | private: |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 65 | class VideoProcessorEncodeCompleteCallback |
pbos@webrtc.org | 7f7162a | 2013-07-30 15:18:31 +0000 | [diff] [blame] | 66 | : public webrtc::EncodedImageCallback { |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 67 | public: |
brandtr | c409552 | 2017-08-07 08:12:33 -0700 | [diff] [blame] | 68 | explicit VideoProcessorEncodeCompleteCallback( |
| 69 | VideoProcessor* video_processor) |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 70 | : video_processor_(video_processor), |
Rasmus Brandt | 4b381af | 2018-02-07 13:56:16 +0100 | [diff] [blame] | 71 | task_queue_(rtc::TaskQueue::Current()) { |
Rasmus Brandt | 5f7a891 | 2018-02-28 17:17:15 +0100 | [diff] [blame] | 72 | RTC_DCHECK(video_processor_); |
Rasmus Brandt | 4b381af | 2018-02-07 13:56:16 +0100 | [diff] [blame] | 73 | RTC_DCHECK(task_queue_); |
| 74 | } |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 75 | |
Sergey Ulanov | 525df3f | 2016-08-02 17:46:41 -0700 | [diff] [blame] | 76 | Result OnEncodedImage( |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 77 | const webrtc::EncodedImage& encoded_image, |
| 78 | const webrtc::CodecSpecificInfo* codec_specific_info, |
brandtr | 8bc9385 | 2017-02-15 05:19:51 -0800 | [diff] [blame] | 79 | const webrtc::RTPFragmentationHeader* fragmentation) override { |
brandtr | 8bc9385 | 2017-02-15 05:19:51 -0800 | [diff] [blame] | 80 | RTC_CHECK(codec_specific_info); |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 81 | |
Rasmus Brandt | 4b381af | 2018-02-07 13:56:16 +0100 | [diff] [blame] | 82 | // Post the callback to the right task queue, if needed. |
| 83 | if (!task_queue_->IsCurrent()) { |
brandtr | 4553562 | 2017-08-22 03:33:11 -0700 | [diff] [blame] | 84 | task_queue_->PostTask( |
| 85 | std::unique_ptr<rtc::QueuedTask>(new EncodeCallbackTask( |
| 86 | video_processor_, encoded_image, codec_specific_info))); |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 87 | return Result(Result::OK, 0); |
| 88 | } |
| 89 | |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 90 | video_processor_->FrameEncoded(encoded_image, *codec_specific_info); |
brandtr | 8bc9385 | 2017-02-15 05:19:51 -0800 | [diff] [blame] | 91 | return Result(Result::OK, 0); |
| 92 | } |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 93 | |
| 94 | private: |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 95 | class EncodeCallbackTask : public rtc::QueuedTask { |
| 96 | public: |
| 97 | EncodeCallbackTask(VideoProcessor* video_processor, |
| 98 | const webrtc::EncodedImage& encoded_image, |
brandtr | 4553562 | 2017-08-22 03:33:11 -0700 | [diff] [blame] | 99 | const webrtc::CodecSpecificInfo* codec_specific_info) |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 100 | : video_processor_(video_processor), |
| 101 | buffer_(encoded_image._buffer, encoded_image._length), |
| 102 | encoded_image_(encoded_image), |
| 103 | codec_specific_info_(*codec_specific_info) { |
| 104 | encoded_image_._buffer = buffer_.data(); |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | bool Run() override { |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 108 | video_processor_->FrameEncoded(encoded_image_, codec_specific_info_); |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 109 | return true; |
| 110 | } |
| 111 | |
| 112 | private: |
| 113 | VideoProcessor* const video_processor_; |
| 114 | rtc::Buffer buffer_; |
| 115 | webrtc::EncodedImage encoded_image_; |
| 116 | const webrtc::CodecSpecificInfo codec_specific_info_; |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 117 | }; |
| 118 | |
brandtr | c409552 | 2017-08-07 08:12:33 -0700 | [diff] [blame] | 119 | VideoProcessor* const video_processor_; |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 120 | rtc::TaskQueue* const task_queue_; |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 121 | }; |
| 122 | |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 123 | class VideoProcessorDecodeCompleteCallback |
philipel | cce46fc | 2015-12-21 03:04:49 -0800 | [diff] [blame] | 124 | : public webrtc::DecodedImageCallback { |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 125 | public: |
brandtr | c409552 | 2017-08-07 08:12:33 -0700 | [diff] [blame] | 126 | explicit VideoProcessorDecodeCompleteCallback( |
Sergey Silkin | 645e2e0 | 2018-04-06 09:42:13 +0200 | [diff] [blame] | 127 | VideoProcessor* video_processor, |
| 128 | size_t simulcast_svc_idx) |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 129 | : video_processor_(video_processor), |
Sergey Silkin | 645e2e0 | 2018-04-06 09:42:13 +0200 | [diff] [blame] | 130 | simulcast_svc_idx_(simulcast_svc_idx), |
Rasmus Brandt | 4b381af | 2018-02-07 13:56:16 +0100 | [diff] [blame] | 131 | task_queue_(rtc::TaskQueue::Current()) { |
Rasmus Brandt | 5f7a891 | 2018-02-28 17:17:15 +0100 | [diff] [blame] | 132 | RTC_DCHECK(video_processor_); |
Rasmus Brandt | 4b381af | 2018-02-07 13:56:16 +0100 | [diff] [blame] | 133 | RTC_DCHECK(task_queue_); |
| 134 | } |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 135 | |
Sami Kalliomäki | 451b29c | 2018-07-04 14:33:51 +0200 | [diff] [blame^] | 136 | int32_t Decoded(webrtc::VideoFrame& image) override; |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 137 | |
philipel | cce46fc | 2015-12-21 03:04:49 -0800 | [diff] [blame] | 138 | int32_t Decoded(webrtc::VideoFrame& image, |
| 139 | int64_t decode_time_ms) override { |
brandtr | 6bb8e0e | 2017-02-20 04:35:52 -0800 | [diff] [blame] | 140 | return Decoded(image); |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 141 | } |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 142 | |
brandtr | 6bb8e0e | 2017-02-20 04:35:52 -0800 | [diff] [blame] | 143 | void Decoded(webrtc::VideoFrame& image, |
Danil Chapovalov | 0040b66 | 2018-06-18 10:48:16 +0200 | [diff] [blame] | 144 | absl::optional<int32_t> decode_time_ms, |
| 145 | absl::optional<uint8_t> qp) override { |
brandtr | bea36fd | 2017-08-07 03:36:54 -0700 | [diff] [blame] | 146 | Decoded(image); |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 147 | } |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 148 | |
| 149 | private: |
brandtr | c409552 | 2017-08-07 08:12:33 -0700 | [diff] [blame] | 150 | VideoProcessor* const video_processor_; |
Sergey Silkin | 645e2e0 | 2018-04-06 09:42:13 +0200 | [diff] [blame] | 151 | const size_t simulcast_svc_idx_; |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 152 | rtc::TaskQueue* const task_queue_; |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 153 | }; |
brandtr | 8bc9385 | 2017-02-15 05:19:51 -0800 | [diff] [blame] | 154 | |
brandtr | bdd555c | 2017-08-21 01:34:04 -0700 | [diff] [blame] | 155 | // Invoked by the callback adapter when a frame has completed encoding. |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 156 | void FrameEncoded(const webrtc::EncodedImage& encoded_image, |
| 157 | const webrtc::CodecSpecificInfo& codec_specific); |
brandtr | 8bc9385 | 2017-02-15 05:19:51 -0800 | [diff] [blame] | 158 | |
brandtr | bdd555c | 2017-08-21 01:34:04 -0700 | [diff] [blame] | 159 | // Invoked by the callback adapter when a frame has completed decoding. |
Sergey Silkin | 645e2e0 | 2018-04-06 09:42:13 +0200 | [diff] [blame] | 160 | void FrameDecoded(const webrtc::VideoFrame& image, size_t simulcast_svc_idx); |
| 161 | |
| 162 | void DecodeFrame(const EncodedImage& encoded_image, size_t simulcast_svc_idx); |
brandtr | 8bc9385 | 2017-02-15 05:19:51 -0800 | [diff] [blame] | 163 | |
Rasmus Brandt | 0f1c0bd | 2018-03-12 10:01:16 +0100 | [diff] [blame] | 164 | // In order to supply the SVC decoders with super frames containing all |
| 165 | // lower layer frames, we merge and store the layer frames in this method. |
Sergey Silkin | 645e2e0 | 2018-04-06 09:42:13 +0200 | [diff] [blame] | 166 | const webrtc::EncodedImage* BuildAndStoreSuperframe( |
Rasmus Brandt | 0f1c0bd | 2018-03-12 10:01:16 +0100 | [diff] [blame] | 167 | const EncodedImage& encoded_image, |
| 168 | const VideoCodecType codec, |
| 169 | size_t frame_number, |
Sergey Silkin | 645e2e0 | 2018-04-06 09:42:13 +0200 | [diff] [blame] | 170 | size_t simulcast_svc_idx, |
| 171 | bool inter_layer_predicted) RTC_RUN_ON(sequence_checker_); |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 172 | |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 173 | // Test input/output. |
Kári Tristan Helgason | 169005d | 2018-05-22 13:34:14 +0200 | [diff] [blame] | 174 | VideoCodecTestFixture::Config config_ RTC_GUARDED_BY(sequence_checker_); |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 175 | const size_t num_simulcast_or_spatial_layers_; |
Kári Tristan Helgason | 169005d | 2018-05-22 13:34:14 +0200 | [diff] [blame] | 176 | VideoCodecTestStats* const stats_; |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 177 | |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 178 | // Codecs. |
brandtr | 8bc9385 | 2017-02-15 05:19:51 -0800 | [diff] [blame] | 179 | webrtc::VideoEncoder* const encoder_; |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 180 | VideoDecoderList* const decoders_; |
brandtr | aebc61e | 2017-02-28 07:13:47 -0800 | [diff] [blame] | 181 | const std::unique_ptr<VideoBitrateAllocator> bitrate_allocator_; |
Erik Språng | 566124a | 2018-04-23 12:32:22 +0200 | [diff] [blame] | 182 | VideoBitrateAllocation bitrate_allocation_ RTC_GUARDED_BY(sequence_checker_); |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 183 | uint32_t framerate_fps_ RTC_GUARDED_BY(sequence_checker_); |
brandtr | aebc61e | 2017-02-28 07:13:47 -0800 | [diff] [blame] | 184 | |
| 185 | // Adapters for the codec callbacks. |
brandtr | bdd555c | 2017-08-21 01:34:04 -0700 | [diff] [blame] | 186 | VideoProcessorEncodeCompleteCallback encode_callback_; |
Sergey Silkin | 645e2e0 | 2018-04-06 09:42:13 +0200 | [diff] [blame] | 187 | // Assign separate callback object to each decoder. This allows us to identify |
| 188 | // decoded layer in frame decode callback. |
| 189 | // simulcast_svc_idx -> decode callback. |
| 190 | std::vector<std::unique_ptr<VideoProcessorDecodeCompleteCallback>> |
| 191 | decode_callback_; |
brandtr | aebc61e | 2017-02-28 07:13:47 -0800 | [diff] [blame] | 192 | |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 193 | // Each call to ProcessFrame() will read one frame from |input_frame_reader_|. |
| 194 | FrameReader* const input_frame_reader_; |
| 195 | |
| 196 | // Input frames are used as reference for frame quality evaluations. |
Sergey Silkin | 64eaa99 | 2017-11-17 14:47:32 +0100 | [diff] [blame] | 197 | // Async codecs might queue frames. To handle that we keep input frame |
| 198 | // and release it after corresponding coded frame is decoded and quality |
| 199 | // measurement is done. |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 200 | // frame_number -> frame. |
| 201 | std::map<size_t, VideoFrame> input_frames_ RTC_GUARDED_BY(sequence_checker_); |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 202 | |
| 203 | // Encoder delivers coded frame layer-by-layer. We store coded frames and |
| 204 | // then, after all layers are encoded, decode them. Such separation of |
| 205 | // frame processing on superframe level simplifies encoding/decoding time |
| 206 | // measurement. |
Rasmus Brandt | 0f1c0bd | 2018-03-12 10:01:16 +0100 | [diff] [blame] | 207 | // simulcast_svc_idx -> merged SVC encoded frame. |
| 208 | std::vector<EncodedImage> merged_encoded_frames_ |
Sergey Silkin | 10d9d59 | 2018-02-01 13:25:17 +0100 | [diff] [blame] | 209 | RTC_GUARDED_BY(sequence_checker_); |
| 210 | |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 211 | // These (optional) file writers are used to persistently store the encoded |
| 212 | // and decoded bitstreams. Each frame writer is enabled by being non-null. |
| 213 | IvfFileWriterList* const encoded_frame_writers_; |
| 214 | FrameWriterList* const decoded_frame_writers_; |
brandtr | 8bc9385 | 2017-02-15 05:19:51 -0800 | [diff] [blame] | 215 | |
Rasmus Brandt | 0f1c0bd | 2018-03-12 10:01:16 +0100 | [diff] [blame] | 216 | // Metadata for inputed/encoded/decoded frames. Used for frame identification, |
| 217 | // frame drop detection, etc. We assume that encoded/decoded frames are |
| 218 | // ordered within each simulcast/spatial layer, but we do not make any |
| 219 | // assumptions of frame ordering between layers. |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 220 | size_t last_inputed_frame_num_ RTC_GUARDED_BY(sequence_checker_); |
| 221 | size_t last_inputed_timestamp_ RTC_GUARDED_BY(sequence_checker_); |
Rasmus Brandt | 0f1c0bd | 2018-03-12 10:01:16 +0100 | [diff] [blame] | 222 | // simulcast_svc_idx -> encode status. |
| 223 | std::vector<bool> first_encoded_frame_ RTC_GUARDED_BY(sequence_checker_); |
| 224 | // simulcast_svc_idx -> frame_number. |
| 225 | std::vector<size_t> last_encoded_frame_num_ RTC_GUARDED_BY(sequence_checker_); |
| 226 | // simulcast_svc_idx -> decode status. |
| 227 | std::vector<bool> first_decoded_frame_ RTC_GUARDED_BY(sequence_checker_); |
| 228 | // simulcast_svc_idx -> frame_number. |
| 229 | std::vector<size_t> last_decoded_frame_num_ RTC_GUARDED_BY(sequence_checker_); |
Sergey Silkin | 5613879 | 2018-05-02 10:50:55 +0200 | [diff] [blame] | 230 | // simulcast_svc_idx -> buffer. |
| 231 | std::vector<rtc::Buffer> decoded_frame_buffer_ |
| 232 | RTC_GUARDED_BY(sequence_checker_); |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 233 | |
Sergey Silkin | c89eed9 | 2018-04-01 23:57:51 +0200 | [diff] [blame] | 234 | // Time spent in frame encode callback. It is accumulated for layers and |
| 235 | // reset when frame encode starts. When next layer is encoded post-encode time |
| 236 | // is substracted from measured encode time. Thus we get pure encode time. |
| 237 | int64_t post_encode_time_ns_ RTC_GUARDED_BY(sequence_checker_); |
| 238 | |
Rasmus Brandt | d062a3c | 2018-03-08 16:45:54 +0100 | [diff] [blame] | 239 | // This class must be operated on a TaskQueue. |
brandtr | c8c5905 | 2017-08-21 06:44:16 -0700 | [diff] [blame] | 240 | rtc::SequencedTaskChecker sequence_checker_; |
brandtr | bdd555c | 2017-08-21 01:34:04 -0700 | [diff] [blame] | 241 | |
| 242 | RTC_DISALLOW_COPY_AND_ASSIGN(VideoProcessor); |
kjellander@webrtc.org | 35a1756 | 2011-10-06 06:44:54 +0000 | [diff] [blame] | 243 | }; |
| 244 | |
| 245 | } // namespace test |
| 246 | } // namespace webrtc |
| 247 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 248 | #endif // MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_H_ |