blob: 2ae739a01fa2dee99f14869cf0d3644fdaff4cae [file] [log] [blame]
andresp@webrtc.orgab654952013-09-19 12:14:03 +00001/*
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 */
pbos@webrtc.org724947b2013-12-11 16:26:16 +000010#include "webrtc/test/frame_generator.h"
andresp@webrtc.orgab654952013-09-19 12:14:03 +000011
pbos@webrtc.org266c7b32013-10-15 09:15:47 +000012#include <math.h>
andresp@webrtc.orgab654952013-09-19 12:14:03 +000013#include <stdio.h>
pbos@webrtc.org266c7b32013-10-15 09:15:47 +000014#include <string.h>
andresp@webrtc.orgab654952013-09-19 12:14:03 +000015
kwibergbfefb032016-05-01 14:53:46 -070016#include <memory>
17
sprang@webrtc.org131bea82015-02-18 12:46:06 +000018#include "webrtc/base/checks.h"
nissef0a7c5a2016-10-31 05:48:07 -070019#include "webrtc/base/keep_ref_until_done.h"
andresp@webrtc.orgab654952013-09-19 12:14:03 +000020#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010021#include "webrtc/system_wrappers/include/clock.h"
nisse115bd152016-09-30 04:14:07 -070022#include "webrtc/test/frame_utils.h"
andresp@webrtc.orgab654952013-09-19 12:14:03 +000023
24namespace webrtc {
25namespace test {
26namespace {
27
pbos@webrtc.org266c7b32013-10-15 09:15:47 +000028class ChromaGenerator : public FrameGenerator {
29 public:
perkjfa10b552016-10-02 23:45:26 -070030 ChromaGenerator(size_t width, size_t height) : angle_(0.0) {
31 ChangeResolution(width, height);
32 }
33
34 void ChangeResolution(size_t width, size_t height) override {
35 rtc::CritScope lock(&crit_);
36 width_ = width;
37 height_ = height;
nisse1996e3f2016-09-19 00:34:46 -070038 RTC_CHECK(width_ > 0);
39 RTC_CHECK(height_ > 0);
40 half_width_ = (width_ + 1) / 2;
41 y_size_ = width_ * height_;
42 uv_size_ = half_width_ * ((height_ + 1) / 2);
pbos@webrtc.org266c7b32013-10-15 09:15:47 +000043 }
44
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -070045 VideoFrame* NextFrame() override {
perkjfa10b552016-10-02 23:45:26 -070046 rtc::CritScope lock(&crit_);
pbos@webrtc.org266c7b32013-10-15 09:15:47 +000047 angle_ += 30.0;
48 uint8_t u = fabs(sin(angle_)) * 0xFF;
49 uint8_t v = fabs(cos(angle_)) * 0xFF;
50
nisse1996e3f2016-09-19 00:34:46 -070051 // Ensure stride == width.
52 rtc::scoped_refptr<I420Buffer> buffer(I420Buffer::Create(
53 static_cast<int>(width_), static_cast<int>(height_),
54 static_cast<int>(width_), static_cast<int>(half_width_),
55 static_cast<int>(half_width_)));
56
57 memset(buffer->MutableDataY(), 0x80, y_size_);
58 memset(buffer->MutableDataU(), u, uv_size_);
59 memset(buffer->MutableDataV(), v, uv_size_);
60
61 frame_.reset(new VideoFrame(buffer, 0, 0, webrtc::kVideoRotation_0));
62 return frame_.get();
pbos@webrtc.org266c7b32013-10-15 09:15:47 +000063 }
64
65 private:
perkjfa10b552016-10-02 23:45:26 -070066 rtc::CriticalSection crit_;
67 double angle_ GUARDED_BY(&crit_);
68 size_t width_ GUARDED_BY(&crit_);
69 size_t height_ GUARDED_BY(&crit_);
70 size_t half_width_ GUARDED_BY(&crit_);
71 size_t y_size_ GUARDED_BY(&crit_);
72 size_t uv_size_ GUARDED_BY(&crit_);
73 std::unique_ptr<VideoFrame> frame_ GUARDED_BY(&crit_);
pbos@webrtc.org266c7b32013-10-15 09:15:47 +000074};
75
andresp@webrtc.orgab654952013-09-19 12:14:03 +000076class YuvFileGenerator : public FrameGenerator {
77 public:
sprang@webrtc.org131bea82015-02-18 12:46:06 +000078 YuvFileGenerator(std::vector<FILE*> files,
79 size_t width,
80 size_t height,
81 int frame_repeat_count)
82 : file_index_(0),
83 files_(files),
84 width_(width),
85 height_(height),
86 frame_size_(CalcBufferSize(kI420,
87 static_cast<int>(width_),
88 static_cast<int>(height_))),
89 frame_buffer_(new uint8_t[frame_size_]),
90 frame_display_count_(frame_repeat_count),
91 current_display_count_(0) {
andresp@webrtc.orgab654952013-09-19 12:14:03 +000092 assert(width > 0);
93 assert(height > 0);
sprang@webrtc.org25dd1db2015-03-02 11:55:45 +000094 assert(frame_repeat_count > 0);
andresp@webrtc.orgab654952013-09-19 12:14:03 +000095 }
96
97 virtual ~YuvFileGenerator() {
sprang@webrtc.org131bea82015-02-18 12:46:06 +000098 for (FILE* file : files_)
99 fclose(file);
andresp@webrtc.orgab654952013-09-19 12:14:03 +0000100 }
101
Miguel Casas-Sanchez47650702015-05-29 17:21:40 -0700102 VideoFrame* NextFrame() override {
sprang@webrtc.org25dd1db2015-03-02 11:55:45 +0000103 if (current_display_count_ == 0)
104 ReadNextFrame();
105 if (++current_display_count_ >= frame_display_count_)
106 current_display_count_ = 0;
andresp@webrtc.orgab654952013-09-19 12:14:03 +0000107
nisse1996e3f2016-09-19 00:34:46 -0700108 temp_frame_.reset(
109 new VideoFrame(last_read_buffer_, 0, 0, webrtc::kVideoRotation_0));
110 return temp_frame_.get();
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000111 }
pbos@webrtc.org724947b2013-12-11 16:26:16 +0000112
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000113 void ReadNextFrame() {
nisse115bd152016-09-30 04:14:07 -0700114 last_read_buffer_ =
115 test::ReadI420Buffer(static_cast<int>(width_),
116 static_cast<int>(height_),
117 files_[file_index_]);
118 if (!last_read_buffer_) {
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000119 // No more frames to read in this file, rewind and move to next file.
120 rewind(files_[file_index_]);
121 file_index_ = (file_index_ + 1) % files_.size();
nisse115bd152016-09-30 04:14:07 -0700122 last_read_buffer_ =
123 test::ReadI420Buffer(static_cast<int>(width_),
124 static_cast<int>(height_),
125 files_[file_index_]);
126 RTC_CHECK(last_read_buffer_);
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000127 }
andresp@webrtc.orgab654952013-09-19 12:14:03 +0000128 }
129
130 private:
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000131 size_t file_index_;
132 const std::vector<FILE*> files_;
133 const size_t width_;
134 const size_t height_;
135 const size_t frame_size_;
kwibergbfefb032016-05-01 14:53:46 -0700136 const std::unique_ptr<uint8_t[]> frame_buffer_;
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000137 const int frame_display_count_;
138 int current_display_count_;
nisse1996e3f2016-09-19 00:34:46 -0700139 rtc::scoped_refptr<I420Buffer> last_read_buffer_;
140 std::unique_ptr<VideoFrame> temp_frame_;
andresp@webrtc.orgab654952013-09-19 12:14:03 +0000141};
sprangd6358952015-07-29 07:58:13 -0700142
143class ScrollingImageFrameGenerator : public FrameGenerator {
144 public:
145 ScrollingImageFrameGenerator(Clock* clock,
146 const std::vector<FILE*>& files,
147 size_t source_width,
148 size_t source_height,
149 size_t target_width,
150 size_t target_height,
151 int64_t scroll_time_ms,
152 int64_t pause_time_ms)
153 : clock_(clock),
154 start_time_(clock->TimeInMilliseconds()),
155 scroll_time_(scroll_time_ms),
156 pause_time_(pause_time_ms),
157 num_frames_(files.size()),
nissef122a852016-10-04 23:27:30 -0700158 target_width_(static_cast<int>(target_width)),
159 target_height_(static_cast<int>(target_height)),
sprangd6358952015-07-29 07:58:13 -0700160 current_frame_num_(num_frames_ - 1),
161 current_source_frame_(nullptr),
162 file_generator_(files, source_width, source_height, 1) {
henrikg91d6ede2015-09-17 00:24:34 -0700163 RTC_DCHECK(clock_ != nullptr);
164 RTC_DCHECK_GT(num_frames_, 0u);
165 RTC_DCHECK_GE(source_height, target_height);
166 RTC_DCHECK_GE(source_width, target_width);
167 RTC_DCHECK_GE(scroll_time_ms, 0);
168 RTC_DCHECK_GE(pause_time_ms, 0);
169 RTC_DCHECK_GT(scroll_time_ms + pause_time_ms, 0);
sprangd6358952015-07-29 07:58:13 -0700170 }
171
172 virtual ~ScrollingImageFrameGenerator() {}
173
174 VideoFrame* NextFrame() override {
175 const int64_t kFrameDisplayTime = scroll_time_ + pause_time_;
176 const int64_t now = clock_->TimeInMilliseconds();
177 int64_t ms_since_start = now - start_time_;
178
179 size_t frame_num = (ms_since_start / kFrameDisplayTime) % num_frames_;
180 UpdateSourceFrame(frame_num);
181
182 double scroll_factor;
183 int64_t time_into_frame = ms_since_start % kFrameDisplayTime;
184 if (time_into_frame < scroll_time_) {
185 scroll_factor = static_cast<double>(time_into_frame) / scroll_time_;
186 } else {
187 scroll_factor = 1.0;
188 }
189 CropSourceToScrolledImage(scroll_factor);
190
191 return &current_frame_;
192 }
193
194 void UpdateSourceFrame(size_t frame_num) {
195 while (current_frame_num_ != frame_num) {
196 current_source_frame_ = file_generator_.NextFrame();
197 current_frame_num_ = (current_frame_num_ + 1) % num_frames_;
198 }
henrikg91d6ede2015-09-17 00:24:34 -0700199 RTC_DCHECK(current_source_frame_ != nullptr);
sprangd6358952015-07-29 07:58:13 -0700200 }
201
202 void CropSourceToScrolledImage(double scroll_factor) {
nissef122a852016-10-04 23:27:30 -0700203 int scroll_margin_x = current_source_frame_->width() - target_width_;
sprangd6358952015-07-29 07:58:13 -0700204 int pixels_scrolled_x =
205 static_cast<int>(scroll_margin_x * scroll_factor + 0.5);
nissef122a852016-10-04 23:27:30 -0700206 int scroll_margin_y = current_source_frame_->height() - target_height_;
sprangd6358952015-07-29 07:58:13 -0700207 int pixels_scrolled_y =
208 static_cast<int>(scroll_margin_y * scroll_factor + 0.5);
209
nissec9c142f2016-05-17 04:05:47 -0700210 int offset_y = (current_source_frame_->video_frame_buffer()->StrideY() *
sprangd6358952015-07-29 07:58:13 -0700211 pixels_scrolled_y) +
212 pixels_scrolled_x;
nissec9c142f2016-05-17 04:05:47 -0700213 int offset_u = (current_source_frame_->video_frame_buffer()->StrideU() *
sprangd6358952015-07-29 07:58:13 -0700214 (pixels_scrolled_y / 2)) +
215 (pixels_scrolled_x / 2);
nissec9c142f2016-05-17 04:05:47 -0700216 int offset_v = (current_source_frame_->video_frame_buffer()->StrideV() *
sprangd6358952015-07-29 07:58:13 -0700217 (pixels_scrolled_y / 2)) +
218 (pixels_scrolled_x / 2);
219
nissef0a7c5a2016-10-31 05:48:07 -0700220 rtc::scoped_refptr<VideoFrameBuffer> frame_buffer(
221 current_source_frame_->video_frame_buffer());
222 current_frame_ = webrtc::VideoFrame(
223 new rtc::RefCountedObject<webrtc::WrappedI420Buffer>(
224 target_width_, target_height_,
225 &frame_buffer->DataY()[offset_y], frame_buffer->StrideY(),
226 &frame_buffer->DataU()[offset_u], frame_buffer->StrideU(),
227 &frame_buffer->DataV()[offset_v], frame_buffer->StrideV(),
228 KeepRefUntilDone(frame_buffer)),
229 kVideoRotation_0, 0);
sprangd6358952015-07-29 07:58:13 -0700230 }
231
232 Clock* const clock_;
233 const int64_t start_time_;
234 const int64_t scroll_time_;
235 const int64_t pause_time_;
236 const size_t num_frames_;
nissef122a852016-10-04 23:27:30 -0700237 const int target_width_;
238 const int target_height_;
239
sprangd6358952015-07-29 07:58:13 -0700240 size_t current_frame_num_;
241 VideoFrame* current_source_frame_;
242 VideoFrame current_frame_;
243 YuvFileGenerator file_generator_;
244};
245
andresp@webrtc.orgab654952013-09-19 12:14:03 +0000246} // namespace
247
perkja49cbd32016-09-16 07:53:41 -0700248FrameForwarder::FrameForwarder() : sink_(nullptr) {}
249
250void FrameForwarder::IncomingCapturedFrame(const VideoFrame& video_frame) {
251 rtc::CritScope lock(&crit_);
252 if (sink_)
253 sink_->OnFrame(video_frame);
254}
255
256void FrameForwarder::AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
257 const rtc::VideoSinkWants& wants) {
258 rtc::CritScope lock(&crit_);
259 RTC_DCHECK(!sink_ || sink_ == sink);
260 sink_ = sink;
261}
262
263void FrameForwarder::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
264 rtc::CritScope lock(&crit_);
265 RTC_DCHECK_EQ(sink, sink_);
266 sink_ = nullptr;
267}
268
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000269FrameGenerator* FrameGenerator::CreateChromaGenerator(size_t width,
270 size_t height) {
pbos@webrtc.org266c7b32013-10-15 09:15:47 +0000271 return new ChromaGenerator(width, height);
272}
273
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000274FrameGenerator* FrameGenerator::CreateFromYuvFile(
275 std::vector<std::string> filenames,
276 size_t width,
277 size_t height,
278 int frame_repeat_count) {
279 assert(!filenames.empty());
280 std::vector<FILE*> files;
281 for (const std::string& filename : filenames) {
282 FILE* file = fopen(filename.c_str(), "rb");
henrikg91d6ede2015-09-17 00:24:34 -0700283 RTC_DCHECK(file != nullptr);
sprang@webrtc.org131bea82015-02-18 12:46:06 +0000284 files.push_back(file);
285 }
286
287 return new YuvFileGenerator(files, width, height, frame_repeat_count);
andresp@webrtc.orgab654952013-09-19 12:14:03 +0000288}
289
sprangd6358952015-07-29 07:58:13 -0700290FrameGenerator* FrameGenerator::CreateScrollingInputFromYuvFiles(
291 Clock* clock,
292 std::vector<std::string> filenames,
293 size_t source_width,
294 size_t source_height,
295 size_t target_width,
296 size_t target_height,
297 int64_t scroll_time_ms,
298 int64_t pause_time_ms) {
299 assert(!filenames.empty());
300 std::vector<FILE*> files;
301 for (const std::string& filename : filenames) {
302 FILE* file = fopen(filename.c_str(), "rb");
henrikg91d6ede2015-09-17 00:24:34 -0700303 RTC_DCHECK(file != nullptr);
sprangd6358952015-07-29 07:58:13 -0700304 files.push_back(file);
305 }
306
307 return new ScrollingImageFrameGenerator(
308 clock, files, source_width, source_height, target_width, target_height,
309 scroll_time_ms, pause_time_ms);
310}
311
andresp@webrtc.orgab654952013-09-19 12:14:03 +0000312} // namespace test
313} // namespace webrtc