andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
| 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 | */ |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 10 | #include "test/frame_generator.h" |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 11 | |
pbos@webrtc.org | 266c7b3 | 2013-10-15 09:15:47 +0000 | [diff] [blame] | 12 | #include <string.h> |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 13 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 14 | #include <cstdint> |
| 15 | #include <cstdio> |
kwiberg | bfefb03 | 2016-05-01 14:53:46 -0700 | [diff] [blame] | 16 | #include <memory> |
| 17 | |
Mirko Bonadei | d970807 | 2019-01-25 20:26:48 +0100 | [diff] [blame] | 18 | #include "api/scoped_refptr.h" |
Emircan Uysaler | 0823eec | 2018-07-13 17:10:00 -0700 | [diff] [blame] | 19 | #include "api/video/i010_buffer.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 20 | #include "api/video/i420_buffer.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 21 | #include "api/video/video_frame_buffer.h" |
| 22 | #include "api/video/video_rotation.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 23 | #include "common_video/include/video_frame_buffer.h" |
| 24 | #include "common_video/libyuv/include/webrtc_libyuv.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 25 | #include "rtc_base/bind.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 26 | #include "rtc_base/checks.h" |
| 27 | #include "rtc_base/keep_ref_until_done.h" |
| 28 | #include "rtc_base/random.h" |
| 29 | #include "system_wrappers/include/clock.h" |
| 30 | #include "test/frame_utils.h" |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 31 | |
| 32 | namespace webrtc { |
| 33 | namespace test { |
| 34 | namespace { |
| 35 | |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 36 | // Helper method for keeping a reference to passed pointers. |
| 37 | void KeepBufferRefs(rtc::scoped_refptr<webrtc::VideoFrameBuffer>, |
| 38 | rtc::scoped_refptr<webrtc::VideoFrameBuffer>) {} |
| 39 | |
erikvarga@webrtc.org | c774d5d | 2017-10-10 14:34:38 +0200 | [diff] [blame] | 40 | // SquareGenerator is a FrameGenerator that draws a given amount of randomly |
| 41 | // sized and colored squares. Between each new generated frame, the squares |
| 42 | // are moved slightly towards the lower right corner. |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 43 | class SquareGenerator : public FrameGenerator { |
pbos@webrtc.org | 266c7b3 | 2013-10-15 09:15:47 +0000 | [diff] [blame] | 44 | public: |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 45 | SquareGenerator(int width, int height, OutputType type, int num_squares) |
| 46 | : type_(type) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 47 | ChangeResolution(width, height); |
erikvarga@webrtc.org | c774d5d | 2017-10-10 14:34:38 +0200 | [diff] [blame] | 48 | for (int i = 0; i < num_squares; ++i) { |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 49 | squares_.emplace_back(new Square(width, height, i + 1)); |
| 50 | } |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 51 | } |
| 52 | |
| 53 | void ChangeResolution(size_t width, size_t height) override { |
| 54 | rtc::CritScope lock(&crit_); |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 55 | width_ = static_cast<int>(width); |
| 56 | height_ = static_cast<int>(height); |
nisse | 1996e3f | 2016-09-19 00:34:46 -0700 | [diff] [blame] | 57 | RTC_CHECK(width_ > 0); |
| 58 | RTC_CHECK(height_ > 0); |
pbos@webrtc.org | 266c7b3 | 2013-10-15 09:15:47 +0000 | [diff] [blame] | 59 | } |
| 60 | |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 61 | rtc::scoped_refptr<I420Buffer> CreateI420Buffer(int width, int height) { |
| 62 | rtc::scoped_refptr<I420Buffer> buffer(I420Buffer::Create(width, height)); |
| 63 | memset(buffer->MutableDataY(), 127, height * buffer->StrideY()); |
Magnus Jedvert | 90e3190 | 2017-06-07 11:32:50 +0200 | [diff] [blame] | 64 | memset(buffer->MutableDataU(), 127, |
| 65 | buffer->ChromaHeight() * buffer->StrideU()); |
| 66 | memset(buffer->MutableDataV(), 127, |
| 67 | buffer->ChromaHeight() * buffer->StrideV()); |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 68 | return buffer; |
| 69 | } |
| 70 | |
| 71 | VideoFrame* NextFrame() override { |
| 72 | rtc::CritScope lock(&crit_); |
| 73 | |
| 74 | rtc::scoped_refptr<VideoFrameBuffer> buffer = nullptr; |
| 75 | switch (type_) { |
Sebastian Jansson | ed0febf | 2019-07-26 15:58:11 +0200 | [diff] [blame] | 76 | case OutputType::kI420: |
| 77 | case OutputType::kI010: { |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 78 | buffer = CreateI420Buffer(width_, height_); |
| 79 | break; |
| 80 | } |
Sebastian Jansson | ed0febf | 2019-07-26 15:58:11 +0200 | [diff] [blame] | 81 | case OutputType::kI420A: { |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 82 | rtc::scoped_refptr<I420Buffer> yuv_buffer = |
| 83 | CreateI420Buffer(width_, height_); |
| 84 | rtc::scoped_refptr<I420Buffer> axx_buffer = |
| 85 | CreateI420Buffer(width_, height_); |
| 86 | buffer = WrapI420ABuffer( |
| 87 | yuv_buffer->width(), yuv_buffer->height(), yuv_buffer->DataY(), |
| 88 | yuv_buffer->StrideY(), yuv_buffer->DataU(), yuv_buffer->StrideU(), |
| 89 | yuv_buffer->DataV(), yuv_buffer->StrideV(), axx_buffer->DataY(), |
| 90 | axx_buffer->StrideY(), |
| 91 | rtc::Bind(&KeepBufferRefs, yuv_buffer, axx_buffer)); |
| 92 | break; |
| 93 | } |
Sebastian Jansson | ed0febf | 2019-07-26 15:58:11 +0200 | [diff] [blame] | 94 | default: |
| 95 | RTC_NOTREACHED() << "The given output format is not supported."; |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 96 | } |
nisse | 1996e3f | 2016-09-19 00:34:46 -0700 | [diff] [blame] | 97 | |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 98 | for (const auto& square : squares_) |
| 99 | square->Draw(buffer); |
nisse | 1996e3f | 2016-09-19 00:34:46 -0700 | [diff] [blame] | 100 | |
Sebastian Jansson | ed0febf | 2019-07-26 15:58:11 +0200 | [diff] [blame] | 101 | if (type_ == OutputType::kI010) { |
Emircan Uysaler | 0823eec | 2018-07-13 17:10:00 -0700 | [diff] [blame] | 102 | buffer = I010Buffer::Copy(*buffer->ToI420()); |
| 103 | } |
| 104 | |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 105 | frame_ = |
| 106 | std::make_unique<VideoFrame>(VideoFrame::Builder() |
| 107 | .set_video_frame_buffer(buffer) |
| 108 | .set_rotation(webrtc::kVideoRotation_0) |
| 109 | .set_timestamp_us(0) |
| 110 | .build()); |
nisse | 1996e3f | 2016-09-19 00:34:46 -0700 | [diff] [blame] | 111 | return frame_.get(); |
pbos@webrtc.org | 266c7b3 | 2013-10-15 09:15:47 +0000 | [diff] [blame] | 112 | } |
| 113 | |
| 114 | private: |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 115 | class Square { |
| 116 | public: |
| 117 | Square(int width, int height, int seed) |
| 118 | : random_generator_(seed), |
| 119 | x_(random_generator_.Rand(0, width)), |
| 120 | y_(random_generator_.Rand(0, height)), |
| 121 | length_(random_generator_.Rand(1, width > 4 ? width / 4 : 1)), |
| 122 | yuv_y_(random_generator_.Rand(0, 255)), |
| 123 | yuv_u_(random_generator_.Rand(0, 255)), |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 124 | yuv_v_(random_generator_.Rand(0, 255)), |
| 125 | yuv_a_(random_generator_.Rand(0, 255)) {} |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 126 | |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 127 | void Draw(const rtc::scoped_refptr<VideoFrameBuffer>& frame_buffer) { |
| 128 | RTC_DCHECK(frame_buffer->type() == VideoFrameBuffer::Type::kI420 || |
| 129 | frame_buffer->type() == VideoFrameBuffer::Type::kI420A); |
| 130 | rtc::scoped_refptr<I420BufferInterface> buffer = frame_buffer->ToI420(); |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 131 | x_ = (x_ + random_generator_.Rand(0, 4)) % (buffer->width() - length_); |
| 132 | y_ = (y_ + random_generator_.Rand(0, 4)) % (buffer->height() - length_); |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 133 | for (int y = y_; y < y_ + length_; ++y) { |
| 134 | uint8_t* pos_y = (const_cast<uint8_t*>(buffer->DataY()) + x_ + |
| 135 | y * buffer->StrideY()); |
| 136 | memset(pos_y, yuv_y_, length_); |
| 137 | } |
perkj | c8b0865 | 2017-03-22 04:57:53 -0700 | [diff] [blame] | 138 | |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 139 | for (int y = y_; y < y_ + length_; y = y + 2) { |
| 140 | uint8_t* pos_u = (const_cast<uint8_t*>(buffer->DataU()) + x_ / 2 + |
| 141 | y / 2 * buffer->StrideU()); |
| 142 | memset(pos_u, yuv_u_, length_ / 2); |
| 143 | uint8_t* pos_v = (const_cast<uint8_t*>(buffer->DataV()) + x_ / 2 + |
| 144 | y / 2 * buffer->StrideV()); |
| 145 | memset(pos_v, yuv_v_, length_ / 2); |
| 146 | } |
| 147 | |
| 148 | if (frame_buffer->type() == VideoFrameBuffer::Type::kI420) |
| 149 | return; |
| 150 | |
| 151 | // Optionally draw on alpha plane if given. |
| 152 | const webrtc::I420ABufferInterface* yuva_buffer = |
| 153 | frame_buffer->GetI420A(); |
| 154 | for (int y = y_; y < y_ + length_; ++y) { |
| 155 | uint8_t* pos_y = (const_cast<uint8_t*>(yuva_buffer->DataA()) + x_ + |
| 156 | y * yuva_buffer->StrideA()); |
| 157 | memset(pos_y, yuv_a_, length_); |
| 158 | } |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | private: |
| 162 | Random random_generator_; |
| 163 | int x_; |
| 164 | int y_; |
| 165 | const int length_; |
| 166 | const uint8_t yuv_y_; |
| 167 | const uint8_t yuv_u_; |
| 168 | const uint8_t yuv_v_; |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 169 | const uint8_t yuv_a_; |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 170 | }; |
| 171 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 172 | rtc::CriticalSection crit_; |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 173 | const OutputType type_; |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 174 | int width_ RTC_GUARDED_BY(&crit_); |
| 175 | int height_ RTC_GUARDED_BY(&crit_); |
| 176 | std::vector<std::unique_ptr<Square>> squares_ RTC_GUARDED_BY(&crit_); |
| 177 | std::unique_ptr<VideoFrame> frame_ RTC_GUARDED_BY(&crit_); |
pbos@webrtc.org | 266c7b3 | 2013-10-15 09:15:47 +0000 | [diff] [blame] | 178 | }; |
| 179 | |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 180 | class YuvFileGenerator : public FrameGenerator { |
| 181 | public: |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 182 | YuvFileGenerator(std::vector<FILE*> files, |
| 183 | size_t width, |
| 184 | size_t height, |
| 185 | int frame_repeat_count) |
| 186 | : file_index_(0), |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 187 | frame_index_(std::numeric_limits<size_t>::max()), |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 188 | files_(files), |
| 189 | width_(width), |
| 190 | height_(height), |
nisse | eb44b39 | 2017-04-28 07:18:05 -0700 | [diff] [blame] | 191 | frame_size_(CalcBufferSize(VideoType::kI420, |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 192 | static_cast<int>(width_), |
| 193 | static_cast<int>(height_))), |
| 194 | frame_buffer_(new uint8_t[frame_size_]), |
| 195 | frame_display_count_(frame_repeat_count), |
| 196 | current_display_count_(0) { |
kwiberg | b890c95c | 2016-11-29 05:30:40 -0800 | [diff] [blame] | 197 | RTC_DCHECK_GT(width, 0); |
| 198 | RTC_DCHECK_GT(height, 0); |
| 199 | RTC_DCHECK_GT(frame_repeat_count, 0); |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 200 | } |
| 201 | |
Mirko Bonadei | fe055c1 | 2019-01-29 22:53:28 +0100 | [diff] [blame] | 202 | ~YuvFileGenerator() override { |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 203 | for (FILE* file : files_) |
| 204 | fclose(file); |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 205 | } |
| 206 | |
Miguel Casas-Sanchez | 4765070 | 2015-05-29 17:21:40 -0700 | [diff] [blame] | 207 | VideoFrame* NextFrame() override { |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 208 | // Empty update by default. |
| 209 | VideoFrame::UpdateRect update_rect{0, 0, 0, 0}; |
| 210 | if (current_display_count_ == 0) { |
| 211 | const bool got_new_frame = ReadNextFrame(); |
| 212 | // Full update on a new frame from file. |
| 213 | if (got_new_frame) { |
| 214 | update_rect = VideoFrame::UpdateRect{0, 0, static_cast<int>(width_), |
| 215 | static_cast<int>(height_)}; |
| 216 | } |
| 217 | } |
sprang@webrtc.org | 25dd1db | 2015-03-02 11:55:45 +0000 | [diff] [blame] | 218 | if (++current_display_count_ >= frame_display_count_) |
| 219 | current_display_count_ = 0; |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 220 | |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 221 | temp_frame_ = std::make_unique<VideoFrame>( |
Artem Titov | 1ebfb6a | 2019-01-03 23:49:37 +0100 | [diff] [blame] | 222 | VideoFrame::Builder() |
| 223 | .set_video_frame_buffer(last_read_buffer_) |
| 224 | .set_rotation(webrtc::kVideoRotation_0) |
| 225 | .set_timestamp_us(0) |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 226 | .set_update_rect(update_rect) |
Artem Titov | 1ebfb6a | 2019-01-03 23:49:37 +0100 | [diff] [blame] | 227 | .build()); |
nisse | 1996e3f | 2016-09-19 00:34:46 -0700 | [diff] [blame] | 228 | return temp_frame_.get(); |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 229 | } |
pbos@webrtc.org | 724947b | 2013-12-11 16:26:16 +0000 | [diff] [blame] | 230 | |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 231 | // Returns true if the new frame was loaded. |
| 232 | // False only in case of a single file with a single frame in it. |
| 233 | bool ReadNextFrame() { |
| 234 | size_t prev_frame_index = frame_index_; |
| 235 | size_t prev_file_index = file_index_; |
nisse | 115bd15 | 2016-09-30 04:14:07 -0700 | [diff] [blame] | 236 | last_read_buffer_ = |
| 237 | test::ReadI420Buffer(static_cast<int>(width_), |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 238 | static_cast<int>(height_), files_[file_index_]); |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 239 | ++frame_index_; |
nisse | 115bd15 | 2016-09-30 04:14:07 -0700 | [diff] [blame] | 240 | if (!last_read_buffer_) { |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 241 | // No more frames to read in this file, rewind and move to next file. |
| 242 | rewind(files_[file_index_]); |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 243 | |
| 244 | frame_index_ = 0; |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 245 | file_index_ = (file_index_ + 1) % files_.size(); |
nisse | 115bd15 | 2016-09-30 04:14:07 -0700 | [diff] [blame] | 246 | last_read_buffer_ = |
| 247 | test::ReadI420Buffer(static_cast<int>(width_), |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 248 | static_cast<int>(height_), files_[file_index_]); |
nisse | 115bd15 | 2016-09-30 04:14:07 -0700 | [diff] [blame] | 249 | RTC_CHECK(last_read_buffer_); |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 250 | } |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 251 | return frame_index_ != prev_frame_index || file_index_ != prev_file_index; |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | private: |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 255 | size_t file_index_; |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 256 | size_t frame_index_; |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 257 | const std::vector<FILE*> files_; |
| 258 | const size_t width_; |
| 259 | const size_t height_; |
| 260 | const size_t frame_size_; |
kwiberg | bfefb03 | 2016-05-01 14:53:46 -0700 | [diff] [blame] | 261 | const std::unique_ptr<uint8_t[]> frame_buffer_; |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 262 | const int frame_display_count_; |
| 263 | int current_display_count_; |
nisse | 1996e3f | 2016-09-19 00:34:46 -0700 | [diff] [blame] | 264 | rtc::scoped_refptr<I420Buffer> last_read_buffer_; |
| 265 | std::unique_ptr<VideoFrame> temp_frame_; |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 266 | }; |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 267 | |
erikvarga | 579de6f | 2017-08-29 09:12:57 -0700 | [diff] [blame] | 268 | // SlideGenerator works similarly to YuvFileGenerator but it fills the frames |
| 269 | // with randomly sized and colored squares instead of reading their content |
| 270 | // from files. |
| 271 | class SlideGenerator : public FrameGenerator { |
| 272 | public: |
| 273 | SlideGenerator(int width, int height, int frame_repeat_count) |
| 274 | : width_(width), |
| 275 | height_(height), |
| 276 | frame_display_count_(frame_repeat_count), |
| 277 | current_display_count_(0), |
| 278 | random_generator_(1234) { |
| 279 | RTC_DCHECK_GT(width, 0); |
| 280 | RTC_DCHECK_GT(height, 0); |
| 281 | RTC_DCHECK_GT(frame_repeat_count, 0); |
| 282 | } |
| 283 | |
| 284 | VideoFrame* NextFrame() override { |
| 285 | if (current_display_count_ == 0) |
| 286 | GenerateNewFrame(); |
| 287 | if (++current_display_count_ >= frame_display_count_) |
| 288 | current_display_count_ = 0; |
| 289 | |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 290 | frame_ = |
| 291 | std::make_unique<VideoFrame>(VideoFrame::Builder() |
| 292 | .set_video_frame_buffer(buffer_) |
| 293 | .set_rotation(webrtc::kVideoRotation_0) |
| 294 | .set_timestamp_us(0) |
| 295 | .build()); |
erikvarga | 579de6f | 2017-08-29 09:12:57 -0700 | [diff] [blame] | 296 | return frame_.get(); |
| 297 | } |
| 298 | |
| 299 | // Generates some randomly sized and colored squares scattered |
| 300 | // over the frame. |
| 301 | void GenerateNewFrame() { |
| 302 | // The squares should have a varying order of magnitude in order |
| 303 | // to simulate variation in the slides' complexity. |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 304 | const int kSquareNum = 1 << (4 + (random_generator_.Rand(0, 3) * 2)); |
erikvarga | 579de6f | 2017-08-29 09:12:57 -0700 | [diff] [blame] | 305 | |
| 306 | buffer_ = I420Buffer::Create(width_, height_); |
| 307 | memset(buffer_->MutableDataY(), 127, height_ * buffer_->StrideY()); |
| 308 | memset(buffer_->MutableDataU(), 127, |
| 309 | buffer_->ChromaHeight() * buffer_->StrideU()); |
| 310 | memset(buffer_->MutableDataV(), 127, |
| 311 | buffer_->ChromaHeight() * buffer_->StrideV()); |
| 312 | |
| 313 | for (int i = 0; i < kSquareNum; ++i) { |
| 314 | int length = random_generator_.Rand(1, width_ > 4 ? width_ / 4 : 1); |
| 315 | // Limit the length of later squares so that they don't overwrite the |
| 316 | // previous ones too much. |
| 317 | length = (length * (kSquareNum - i)) / kSquareNum; |
| 318 | |
| 319 | int x = random_generator_.Rand(0, width_ - length); |
| 320 | int y = random_generator_.Rand(0, height_ - length); |
| 321 | uint8_t yuv_y = random_generator_.Rand(0, 255); |
| 322 | uint8_t yuv_u = random_generator_.Rand(0, 255); |
| 323 | uint8_t yuv_v = random_generator_.Rand(0, 255); |
| 324 | |
| 325 | for (int yy = y; yy < y + length; ++yy) { |
| 326 | uint8_t* pos_y = |
| 327 | (buffer_->MutableDataY() + x + yy * buffer_->StrideY()); |
| 328 | memset(pos_y, yuv_y, length); |
| 329 | } |
| 330 | for (int yy = y; yy < y + length; yy += 2) { |
| 331 | uint8_t* pos_u = |
| 332 | (buffer_->MutableDataU() + x / 2 + yy / 2 * buffer_->StrideU()); |
| 333 | memset(pos_u, yuv_u, length / 2); |
| 334 | uint8_t* pos_v = |
| 335 | (buffer_->MutableDataV() + x / 2 + yy / 2 * buffer_->StrideV()); |
| 336 | memset(pos_v, yuv_v, length / 2); |
| 337 | } |
| 338 | } |
| 339 | } |
| 340 | |
| 341 | private: |
| 342 | const int width_; |
| 343 | const int height_; |
| 344 | const int frame_display_count_; |
| 345 | int current_display_count_; |
| 346 | Random random_generator_; |
| 347 | rtc::scoped_refptr<I420Buffer> buffer_; |
| 348 | std::unique_ptr<VideoFrame> frame_; |
| 349 | }; |
| 350 | |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 351 | class ScrollingImageFrameGenerator : public FrameGenerator { |
| 352 | public: |
| 353 | ScrollingImageFrameGenerator(Clock* clock, |
| 354 | const std::vector<FILE*>& files, |
| 355 | size_t source_width, |
| 356 | size_t source_height, |
| 357 | size_t target_width, |
| 358 | size_t target_height, |
| 359 | int64_t scroll_time_ms, |
| 360 | int64_t pause_time_ms) |
| 361 | : clock_(clock), |
| 362 | start_time_(clock->TimeInMilliseconds()), |
| 363 | scroll_time_(scroll_time_ms), |
| 364 | pause_time_(pause_time_ms), |
| 365 | num_frames_(files.size()), |
nisse | f122a85 | 2016-10-04 23:27:30 -0700 | [diff] [blame] | 366 | target_width_(static_cast<int>(target_width)), |
| 367 | target_height_(static_cast<int>(target_height)), |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 368 | current_frame_num_(num_frames_ - 1), |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 369 | prev_frame_not_scrolled_(false), |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 370 | current_source_frame_(nullptr), |
| 371 | file_generator_(files, source_width, source_height, 1) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 372 | RTC_DCHECK(clock_ != nullptr); |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 373 | RTC_DCHECK_GT(num_frames_, 0); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 374 | RTC_DCHECK_GE(source_height, target_height); |
| 375 | RTC_DCHECK_GE(source_width, target_width); |
| 376 | RTC_DCHECK_GE(scroll_time_ms, 0); |
| 377 | RTC_DCHECK_GE(pause_time_ms, 0); |
| 378 | RTC_DCHECK_GT(scroll_time_ms + pause_time_ms, 0); |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 379 | } |
| 380 | |
Mirko Bonadei | fe055c1 | 2019-01-29 22:53:28 +0100 | [diff] [blame] | 381 | ~ScrollingImageFrameGenerator() override {} |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 382 | |
| 383 | VideoFrame* NextFrame() override { |
| 384 | const int64_t kFrameDisplayTime = scroll_time_ + pause_time_; |
| 385 | const int64_t now = clock_->TimeInMilliseconds(); |
| 386 | int64_t ms_since_start = now - start_time_; |
| 387 | |
| 388 | size_t frame_num = (ms_since_start / kFrameDisplayTime) % num_frames_; |
| 389 | UpdateSourceFrame(frame_num); |
| 390 | |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 391 | bool cur_frame_not_scrolled; |
| 392 | |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 393 | double scroll_factor; |
| 394 | int64_t time_into_frame = ms_since_start % kFrameDisplayTime; |
| 395 | if (time_into_frame < scroll_time_) { |
| 396 | scroll_factor = static_cast<double>(time_into_frame) / scroll_time_; |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 397 | cur_frame_not_scrolled = false; |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 398 | } else { |
| 399 | scroll_factor = 1.0; |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 400 | cur_frame_not_scrolled = true; |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 401 | } |
| 402 | CropSourceToScrolledImage(scroll_factor); |
| 403 | |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 404 | bool same_scroll_position = |
| 405 | prev_frame_not_scrolled_ && cur_frame_not_scrolled; |
| 406 | if (!same_scroll_position && current_frame_) { |
| 407 | // If scrolling is not finished yet, force full frame update. |
| 408 | current_frame_->set_update_rect( |
| 409 | VideoFrame::UpdateRect{0, 0, target_width_, target_height_}); |
| 410 | } |
| 411 | prev_frame_not_scrolled_ = cur_frame_not_scrolled; |
| 412 | |
nisse | df2ceb8 | 2016-12-15 06:29:53 -0800 | [diff] [blame] | 413 | return current_frame_ ? &*current_frame_ : nullptr; |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 414 | } |
| 415 | |
| 416 | void UpdateSourceFrame(size_t frame_num) { |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 417 | VideoFrame::UpdateRect acc_update{0, 0, 0, 0}; |
Ilya Nikolaevskiy | 6cfb403 | 2019-02-06 10:56:39 +0100 | [diff] [blame] | 418 | while (current_frame_num_ != frame_num || |
| 419 | current_source_frame_ == nullptr) { |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 420 | current_source_frame_ = file_generator_.NextFrame(); |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 421 | if (current_source_frame_) |
| 422 | acc_update.Union(current_source_frame_->update_rect()); |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 423 | current_frame_num_ = (current_frame_num_ + 1) % num_frames_; |
| 424 | } |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 425 | RTC_DCHECK(current_source_frame_ != nullptr); |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 426 | current_source_frame_->set_update_rect(acc_update); |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 427 | } |
| 428 | |
| 429 | void CropSourceToScrolledImage(double scroll_factor) { |
nisse | f122a85 | 2016-10-04 23:27:30 -0700 | [diff] [blame] | 430 | int scroll_margin_x = current_source_frame_->width() - target_width_; |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 431 | int pixels_scrolled_x = |
| 432 | static_cast<int>(scroll_margin_x * scroll_factor + 0.5); |
nisse | f122a85 | 2016-10-04 23:27:30 -0700 | [diff] [blame] | 433 | int scroll_margin_y = current_source_frame_->height() - target_height_; |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 434 | int pixels_scrolled_y = |
| 435 | static_cast<int>(scroll_margin_y * scroll_factor + 0.5); |
| 436 | |
Magnus Jedvert | 90e3190 | 2017-06-07 11:32:50 +0200 | [diff] [blame] | 437 | rtc::scoped_refptr<I420BufferInterface> i420_buffer = |
| 438 | current_source_frame_->video_frame_buffer()->ToI420(); |
| 439 | int offset_y = |
| 440 | (i420_buffer->StrideY() * pixels_scrolled_y) + pixels_scrolled_x; |
| 441 | int offset_u = (i420_buffer->StrideU() * (pixels_scrolled_y / 2)) + |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 442 | (pixels_scrolled_x / 2); |
Magnus Jedvert | 90e3190 | 2017-06-07 11:32:50 +0200 | [diff] [blame] | 443 | int offset_v = (i420_buffer->StrideV() * (pixels_scrolled_y / 2)) + |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 444 | (pixels_scrolled_x / 2); |
| 445 | |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 446 | VideoFrame::UpdateRect update_rect = |
| 447 | current_source_frame_->update_rect().IsEmpty() |
| 448 | ? VideoFrame::UpdateRect{0, 0, 0, 0} |
| 449 | : VideoFrame::UpdateRect{0, 0, target_width_, target_height_}; |
Artem Titov | 1ebfb6a | 2019-01-03 23:49:37 +0100 | [diff] [blame] | 450 | current_frame_ = |
| 451 | VideoFrame::Builder() |
| 452 | .set_video_frame_buffer(WrapI420Buffer( |
| 453 | target_width_, target_height_, &i420_buffer->DataY()[offset_y], |
| 454 | i420_buffer->StrideY(), &i420_buffer->DataU()[offset_u], |
| 455 | i420_buffer->StrideU(), &i420_buffer->DataV()[offset_v], |
| 456 | i420_buffer->StrideV(), KeepRefUntilDone(i420_buffer))) |
| 457 | .set_rotation(kVideoRotation_0) |
| 458 | .set_timestamp_us(0) |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 459 | .set_update_rect(update_rect) |
Artem Titov | 1ebfb6a | 2019-01-03 23:49:37 +0100 | [diff] [blame] | 460 | .build(); |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 461 | } |
| 462 | |
| 463 | Clock* const clock_; |
| 464 | const int64_t start_time_; |
| 465 | const int64_t scroll_time_; |
| 466 | const int64_t pause_time_; |
| 467 | const size_t num_frames_; |
nisse | f122a85 | 2016-10-04 23:27:30 -0700 | [diff] [blame] | 468 | const int target_width_; |
| 469 | const int target_height_; |
| 470 | |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 471 | size_t current_frame_num_; |
Ilya Nikolaevskiy | d0f3d84 | 2019-03-04 15:10:44 +0100 | [diff] [blame] | 472 | bool prev_frame_not_scrolled_; |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 473 | VideoFrame* current_source_frame_; |
Danil Chapovalov | 431abd9 | 2018-06-18 12:54:17 +0200 | [diff] [blame] | 474 | absl::optional<VideoFrame> current_frame_; |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 475 | YuvFileGenerator file_generator_; |
| 476 | }; |
| 477 | |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 478 | } // namespace |
| 479 | |
perkj | a49cbd3 | 2016-09-16 07:53:41 -0700 | [diff] [blame] | 480 | FrameForwarder::FrameForwarder() : sink_(nullptr) {} |
sprang | b1ca073 | 2017-02-01 08:38:12 -0800 | [diff] [blame] | 481 | FrameForwarder::~FrameForwarder() {} |
perkj | a49cbd3 | 2016-09-16 07:53:41 -0700 | [diff] [blame] | 482 | |
| 483 | void FrameForwarder::IncomingCapturedFrame(const VideoFrame& video_frame) { |
| 484 | rtc::CritScope lock(&crit_); |
| 485 | if (sink_) |
| 486 | sink_->OnFrame(video_frame); |
| 487 | } |
| 488 | |
| 489 | void FrameForwarder::AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink, |
| 490 | const rtc::VideoSinkWants& wants) { |
| 491 | rtc::CritScope lock(&crit_); |
| 492 | RTC_DCHECK(!sink_ || sink_ == sink); |
| 493 | sink_ = sink; |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 494 | sink_wants_ = wants; |
perkj | a49cbd3 | 2016-09-16 07:53:41 -0700 | [diff] [blame] | 495 | } |
| 496 | |
| 497 | void FrameForwarder::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) { |
| 498 | rtc::CritScope lock(&crit_); |
| 499 | RTC_DCHECK_EQ(sink, sink_); |
| 500 | sink_ = nullptr; |
| 501 | } |
| 502 | |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 503 | rtc::VideoSinkWants FrameForwarder::sink_wants() const { |
| 504 | rtc::CritScope lock(&crit_); |
| 505 | return sink_wants_; |
| 506 | } |
| 507 | |
| 508 | bool FrameForwarder::has_sinks() const { |
| 509 | rtc::CritScope lock(&crit_); |
| 510 | return sink_ != nullptr; |
| 511 | } |
| 512 | |
Artem Titov | f50c6c2 | 2019-01-24 16:54:03 +0100 | [diff] [blame] | 513 | void FrameGenerator::ChangeResolution(size_t width, size_t height) { |
| 514 | RTC_NOTREACHED(); |
| 515 | } |
| 516 | |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 517 | std::unique_ptr<FrameGenerator> FrameGenerator::CreateSquareGenerator( |
| 518 | int width, |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 519 | int height, |
Danil Chapovalov | 431abd9 | 2018-06-18 12:54:17 +0200 | [diff] [blame] | 520 | absl::optional<OutputType> type, |
| 521 | absl::optional<int> num_squares) { |
erikvarga@webrtc.org | c774d5d | 2017-10-10 14:34:38 +0200 | [diff] [blame] | 522 | return std::unique_ptr<FrameGenerator>( |
Sebastian Jansson | ed0febf | 2019-07-26 15:58:11 +0200 | [diff] [blame] | 523 | new SquareGenerator(width, height, type.value_or(OutputType::kI420), |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 524 | num_squares.value_or(10))); |
pbos@webrtc.org | 266c7b3 | 2013-10-15 09:15:47 +0000 | [diff] [blame] | 525 | } |
| 526 | |
erikvarga | 579de6f | 2017-08-29 09:12:57 -0700 | [diff] [blame] | 527 | std::unique_ptr<FrameGenerator> FrameGenerator::CreateSlideGenerator( |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 528 | int width, |
| 529 | int height, |
| 530 | int frame_repeat_count) { |
| 531 | return std::unique_ptr<FrameGenerator>( |
| 532 | new SlideGenerator(width, height, frame_repeat_count)); |
erikvarga | 579de6f | 2017-08-29 09:12:57 -0700 | [diff] [blame] | 533 | } |
| 534 | |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 535 | std::unique_ptr<FrameGenerator> FrameGenerator::CreateFromYuvFile( |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 536 | std::vector<std::string> filenames, |
| 537 | size_t width, |
| 538 | size_t height, |
| 539 | int frame_repeat_count) { |
kwiberg | b890c95c | 2016-11-29 05:30:40 -0800 | [diff] [blame] | 540 | RTC_DCHECK(!filenames.empty()); |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 541 | std::vector<FILE*> files; |
| 542 | for (const std::string& filename : filenames) { |
| 543 | FILE* file = fopen(filename.c_str(), "rb"); |
Sebastian Jansson | 9eda327 | 2018-09-13 16:23:03 +0200 | [diff] [blame] | 544 | RTC_DCHECK(file != nullptr) << "Failed to open: '" << filename << "'\n"; |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 545 | files.push_back(file); |
| 546 | } |
| 547 | |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 548 | return std::unique_ptr<FrameGenerator>( |
| 549 | new YuvFileGenerator(files, width, height, frame_repeat_count)); |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 550 | } |
| 551 | |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 552 | std::unique_ptr<FrameGenerator> |
| 553 | FrameGenerator::CreateScrollingInputFromYuvFiles( |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 554 | Clock* clock, |
| 555 | std::vector<std::string> filenames, |
| 556 | size_t source_width, |
| 557 | size_t source_height, |
| 558 | size_t target_width, |
| 559 | size_t target_height, |
| 560 | int64_t scroll_time_ms, |
| 561 | int64_t pause_time_ms) { |
kwiberg | b890c95c | 2016-11-29 05:30:40 -0800 | [diff] [blame] | 562 | RTC_DCHECK(!filenames.empty()); |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 563 | std::vector<FILE*> files; |
| 564 | for (const std::string& filename : filenames) { |
| 565 | FILE* file = fopen(filename.c_str(), "rb"); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 566 | RTC_DCHECK(file != nullptr); |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 567 | files.push_back(file); |
| 568 | } |
| 569 | |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 570 | return std::unique_ptr<FrameGenerator>(new ScrollingImageFrameGenerator( |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 571 | clock, files, source_width, source_height, target_width, target_height, |
perkj | a8ba195 | 2017-02-27 06:52:10 -0800 | [diff] [blame] | 572 | scroll_time_ms, pause_time_ms)); |
sprang | d635895 | 2015-07-29 07:58:13 -0700 | [diff] [blame] | 573 | } |
| 574 | |
andresp@webrtc.org | ab65495 | 2013-09-19 12:14:03 +0000 | [diff] [blame] | 575 | } // namespace test |
| 576 | } // namespace webrtc |