Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright (c) 2013 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.
*/
#include "test/frame_generator.h"
#include <string.h>
#include <cstdint>
#include <cstdio>
#include <memory>
#include "api/video/i010_buffer.h"
#include "api/video/nv12_buffer.h"
#include "api/video/video_rotation.h"
#include "common_video/include/video_frame_buffer.h"
#include "common_video/libyuv/include/webrtc_libyuv.h"
#include "rtc_base/checks.h"
#include "test/frame_utils.h"
namespace webrtc {
namespace test {
SquareGenerator::SquareGenerator(int width,
int height,
OutputType type,
int num_squares)
: type_(type) {
ChangeResolution(width, height);
for (int i = 0; i < num_squares; ++i) {
squares_.emplace_back(new Square(width, height, i + 1));
}
}
void SquareGenerator::ChangeResolution(size_t width, size_t height) {
MutexLock lock(&mutex_);
width_ = static_cast<int>(width);
height_ = static_cast<int>(height);
RTC_CHECK(width_ > 0);
RTC_CHECK(height_ > 0);
}
FrameGeneratorInterface::Resolution SquareGenerator::GetResolution() const {
MutexLock lock(&mutex_);
return {.width = static_cast<size_t>(width_),
.height = static_cast<size_t>(height_)};
}
rtc::scoped_refptr<I420Buffer> SquareGenerator::CreateI420Buffer(int width,
int height) {
rtc::scoped_refptr<I420Buffer> buffer(I420Buffer::Create(width, height));
memset(buffer->MutableDataY(), 127, height * buffer->StrideY());
memset(buffer->MutableDataU(), 127,
buffer->ChromaHeight() * buffer->StrideU());
memset(buffer->MutableDataV(), 127,
buffer->ChromaHeight() * buffer->StrideV());
return buffer;
}
FrameGeneratorInterface::VideoFrameData SquareGenerator::NextFrame() {
MutexLock lock(&mutex_);
rtc::scoped_refptr<VideoFrameBuffer> buffer = nullptr;
switch (type_) {
case OutputType::kI420:
case OutputType::kI010:
case OutputType::kNV12: {
buffer = CreateI420Buffer(width_, height_);
break;
}
case OutputType::kI420A: {
rtc::scoped_refptr<I420Buffer> yuv_buffer =
CreateI420Buffer(width_, height_);
rtc::scoped_refptr<I420Buffer> axx_buffer =
CreateI420Buffer(width_, height_);
buffer = WrapI420ABuffer(yuv_buffer->width(), yuv_buffer->height(),
yuv_buffer->DataY(), yuv_buffer->StrideY(),
yuv_buffer->DataU(), yuv_buffer->StrideU(),
yuv_buffer->DataV(), yuv_buffer->StrideV(),
axx_buffer->DataY(), axx_buffer->StrideY(),
// To keep references alive.
[yuv_buffer, axx_buffer] {});
break;
}
default:
RTC_DCHECK_NOTREACHED() << "The given output format is not supported.";
}
for (const auto& square : squares_)
square->Draw(buffer);
if (type_ == OutputType::kI010) {
buffer = I010Buffer::Copy(*buffer->ToI420());
} else if (type_ == OutputType::kNV12) {
buffer = NV12Buffer::Copy(*buffer->ToI420());
}
return VideoFrameData(buffer, absl::nullopt);
}
SquareGenerator::Square::Square(int width, int height, int seed)
: random_generator_(seed),
x_(random_generator_.Rand(0, width)),
y_(random_generator_.Rand(0, height)),
length_(random_generator_.Rand(1, width > 4 ? width / 4 : 1)),
yuv_y_(random_generator_.Rand(0, 255)),
yuv_u_(random_generator_.Rand(0, 255)),
yuv_v_(random_generator_.Rand(0, 255)),
yuv_a_(random_generator_.Rand(0, 255)) {}
void SquareGenerator::Square::Draw(
const rtc::scoped_refptr<VideoFrameBuffer>& frame_buffer) {
RTC_DCHECK(frame_buffer->type() == VideoFrameBuffer::Type::kI420 ||
frame_buffer->type() == VideoFrameBuffer::Type::kI420A);
rtc::scoped_refptr<I420BufferInterface> buffer = frame_buffer->ToI420();
int length_cap = std::min(buffer->height(), buffer->width()) / 4;
int length = std::min(length_, length_cap);
x_ = (x_ + random_generator_.Rand(0, 4)) % (buffer->width() - length);
y_ = (y_ + random_generator_.Rand(0, 4)) % (buffer->height() - length);
for (int y = y_; y < y_ + length; ++y) {
uint8_t* pos_y =
(const_cast<uint8_t*>(buffer->DataY()) + x_ + y * buffer->StrideY());
memset(pos_y, yuv_y_, length);
}
for (int y = y_; y < y_ + length; y = y + 2) {
uint8_t* pos_u = (const_cast<uint8_t*>(buffer->DataU()) + x_ / 2 +
y / 2 * buffer->StrideU());
memset(pos_u, yuv_u_, length / 2);
uint8_t* pos_v = (const_cast<uint8_t*>(buffer->DataV()) + x_ / 2 +
y / 2 * buffer->StrideV());
memset(pos_v, yuv_v_, length / 2);
}
if (frame_buffer->type() == VideoFrameBuffer::Type::kI420)
return;
// Optionally draw on alpha plane if given.
const webrtc::I420ABufferInterface* yuva_buffer = frame_buffer->GetI420A();
for (int y = y_; y < y_ + length; ++y) {
uint8_t* pos_y = (const_cast<uint8_t*>(yuva_buffer->DataA()) + x_ +
y * yuva_buffer->StrideA());
memset(pos_y, yuv_a_, length);
}
}
YuvFileGenerator::YuvFileGenerator(std::vector<FILE*> files,
size_t width,
size_t height,
int frame_repeat_count)
: file_index_(0),
frame_index_(std::numeric_limits<size_t>::max()),
files_(files),
width_(width),
height_(height),
frame_size_(CalcBufferSize(VideoType::kI420,
static_cast<int>(width_),
static_cast<int>(height_))),
frame_buffer_(new uint8_t[frame_size_]),
frame_display_count_(frame_repeat_count),
current_display_count_(0) {
RTC_DCHECK_GT(width, 0);
RTC_DCHECK_GT(height, 0);
RTC_DCHECK_GT(frame_repeat_count, 0);
}
YuvFileGenerator::~YuvFileGenerator() {
for (FILE* file : files_)
fclose(file);
}
FrameGeneratorInterface::VideoFrameData YuvFileGenerator::NextFrame() {
// Empty update by default.
VideoFrame::UpdateRect update_rect{0, 0, 0, 0};
if (current_display_count_ == 0) {
const bool got_new_frame = ReadNextFrame();
// Full update on a new frame from file.
if (got_new_frame) {
update_rect = VideoFrame::UpdateRect{0, 0, static_cast<int>(width_),
static_cast<int>(height_)};
}
}
if (++current_display_count_ >= frame_display_count_)
current_display_count_ = 0;
return VideoFrameData(last_read_buffer_, update_rect);
}
bool YuvFileGenerator::ReadNextFrame() {
size_t prev_frame_index = frame_index_;
size_t prev_file_index = file_index_;
last_read_buffer_ = test::ReadI420Buffer(
static_cast<int>(width_), static_cast<int>(height_), files_[file_index_]);
++frame_index_;
if (!last_read_buffer_) {
// No more frames to read in this file, rewind and move to next file.
rewind(files_[file_index_]);
frame_index_ = 0;
file_index_ = (file_index_ + 1) % files_.size();
last_read_buffer_ =
test::ReadI420Buffer(static_cast<int>(width_),
static_cast<int>(height_), files_[file_index_]);
RTC_CHECK(last_read_buffer_);
}
return frame_index_ != prev_frame_index || file_index_ != prev_file_index;
}
FrameGeneratorInterface::Resolution YuvFileGenerator::GetResolution() const {
return {.width = width_, .height = height_};
}
NV12FileGenerator::NV12FileGenerator(std::vector<FILE*> files,
size_t width,
size_t height,
int frame_repeat_count)
: file_index_(0),
frame_index_(std::numeric_limits<size_t>::max()),
files_(files),
width_(width),
height_(height),
frame_size_(CalcBufferSize(VideoType::kNV12,
static_cast<int>(width_),
static_cast<int>(height_))),
frame_buffer_(new uint8_t[frame_size_]),
frame_display_count_(frame_repeat_count),
current_display_count_(0) {
RTC_DCHECK_GT(width, 0);
RTC_DCHECK_GT(height, 0);
RTC_DCHECK_GT(frame_repeat_count, 0);
}
NV12FileGenerator::~NV12FileGenerator() {
for (FILE* file : files_)
fclose(file);
}
FrameGeneratorInterface::VideoFrameData NV12FileGenerator::NextFrame() {
// Empty update by default.
VideoFrame::UpdateRect update_rect{0, 0, 0, 0};
if (current_display_count_ == 0) {
const bool got_new_frame = ReadNextFrame();
// Full update on a new frame from file.
if (got_new_frame) {
update_rect = VideoFrame::UpdateRect{0, 0, static_cast<int>(width_),
static_cast<int>(height_)};
}
}
if (++current_display_count_ >= frame_display_count_)
current_display_count_ = 0;
return VideoFrameData(last_read_buffer_, update_rect);
}
FrameGeneratorInterface::Resolution NV12FileGenerator::GetResolution() const {
return {.width = width_, .height = height_};
}
bool NV12FileGenerator::ReadNextFrame() {
size_t prev_frame_index = frame_index_;
size_t prev_file_index = file_index_;
last_read_buffer_ = test::ReadNV12Buffer(
static_cast<int>(width_), static_cast<int>(height_), files_[file_index_]);
++frame_index_;
if (!last_read_buffer_) {
// No more frames to read in this file, rewind and move to next file.
rewind(files_[file_index_]);
frame_index_ = 0;
file_index_ = (file_index_ + 1) % files_.size();
last_read_buffer_ =
test::ReadNV12Buffer(static_cast<int>(width_),
static_cast<int>(height_), files_[file_index_]);
RTC_CHECK(last_read_buffer_);
}
return frame_index_ != prev_frame_index || file_index_ != prev_file_index;
}
SlideGenerator::SlideGenerator(int width, int height, int frame_repeat_count)
: width_(width),
height_(height),
frame_display_count_(frame_repeat_count),
current_display_count_(0),
random_generator_(1234) {
RTC_DCHECK_GT(width, 0);
RTC_DCHECK_GT(height, 0);
RTC_DCHECK_GT(frame_repeat_count, 0);
}
FrameGeneratorInterface::VideoFrameData SlideGenerator::NextFrame() {
if (current_display_count_ == 0)
GenerateNewFrame();
if (++current_display_count_ >= frame_display_count_)
current_display_count_ = 0;
return VideoFrameData(buffer_, absl::nullopt);
}
FrameGeneratorInterface::Resolution SlideGenerator::GetResolution() const {
return {.width = static_cast<size_t>(width_),
.height = static_cast<size_t>(height_)};
}
void SlideGenerator::GenerateNewFrame() {
// The squares should have a varying order of magnitude in order
// to simulate variation in the slides' complexity.
const int kSquareNum = 1 << (4 + (random_generator_.Rand(0, 3) * 2));
buffer_ = I420Buffer::Create(width_, height_);
memset(buffer_->MutableDataY(), 127, height_ * buffer_->StrideY());
memset(buffer_->MutableDataU(), 127,
buffer_->ChromaHeight() * buffer_->StrideU());
memset(buffer_->MutableDataV(), 127,
buffer_->ChromaHeight() * buffer_->StrideV());
for (int i = 0; i < kSquareNum; ++i) {
int length = random_generator_.Rand(1, width_ > 4 ? width_ / 4 : 1);
// Limit the length of later squares so that they don't overwrite the
// previous ones too much.
length = (length * (kSquareNum - i)) / kSquareNum;
int x = random_generator_.Rand(0, width_ - length);
int y = random_generator_.Rand(0, height_ - length);
uint8_t yuv_y = random_generator_.Rand(0, 255);
uint8_t yuv_u = random_generator_.Rand(0, 255);
uint8_t yuv_v = random_generator_.Rand(0, 255);
for (int yy = y; yy < y + length; ++yy) {
uint8_t* pos_y = (buffer_->MutableDataY() + x + yy * buffer_->StrideY());
memset(pos_y, yuv_y, length);
}
for (int yy = y; yy < y + length; yy += 2) {
uint8_t* pos_u =
(buffer_->MutableDataU() + x / 2 + yy / 2 * buffer_->StrideU());
memset(pos_u, yuv_u, length / 2);
uint8_t* pos_v =
(buffer_->MutableDataV() + x / 2 + yy / 2 * buffer_->StrideV());
memset(pos_v, yuv_v, length / 2);
}
}
}
ScrollingImageFrameGenerator::ScrollingImageFrameGenerator(
Clock* clock,
const std::vector<FILE*>& files,
size_t source_width,
size_t source_height,
size_t target_width,
size_t target_height,
int64_t scroll_time_ms,
int64_t pause_time_ms)
: clock_(clock),
start_time_(clock->TimeInMilliseconds()),
scroll_time_(scroll_time_ms),
pause_time_(pause_time_ms),
num_frames_(files.size()),
target_width_(static_cast<int>(target_width)),
target_height_(static_cast<int>(target_height)),
current_frame_num_(num_frames_ - 1),
prev_frame_not_scrolled_(false),
current_source_frame_(nullptr, absl::nullopt),
current_frame_(nullptr, absl::nullopt),
file_generator_(files, source_width, source_height, 1) {
RTC_DCHECK(clock_ != nullptr);
RTC_DCHECK_GT(num_frames_, 0);
RTC_DCHECK_GE(source_height, target_height);
RTC_DCHECK_GE(source_width, target_width);
RTC_DCHECK_GE(scroll_time_ms, 0);
RTC_DCHECK_GE(pause_time_ms, 0);
RTC_DCHECK_GT(scroll_time_ms + pause_time_ms, 0);
}
FrameGeneratorInterface::VideoFrameData
ScrollingImageFrameGenerator::NextFrame() {
const int64_t kFrameDisplayTime = scroll_time_ + pause_time_;
const int64_t now = clock_->TimeInMilliseconds();
int64_t ms_since_start = now - start_time_;
size_t frame_num = (ms_since_start / kFrameDisplayTime) % num_frames_;
UpdateSourceFrame(frame_num);
bool cur_frame_not_scrolled;
double scroll_factor;
int64_t time_into_frame = ms_since_start % kFrameDisplayTime;
if (time_into_frame < scroll_time_) {
scroll_factor = static_cast<double>(time_into_frame) / scroll_time_;
cur_frame_not_scrolled = false;
} else {
scroll_factor = 1.0;
cur_frame_not_scrolled = true;
}
CropSourceToScrolledImage(scroll_factor);
bool same_scroll_position =
prev_frame_not_scrolled_ && cur_frame_not_scrolled;
if (!same_scroll_position) {
// If scrolling is not finished yet, force full frame update.
current_frame_.update_rect =
VideoFrame::UpdateRect{0, 0, target_width_, target_height_};
}
prev_frame_not_scrolled_ = cur_frame_not_scrolled;
return current_frame_;
}
FrameGeneratorInterface::Resolution
ScrollingImageFrameGenerator::GetResolution() const {
return {.width = static_cast<size_t>(target_width_),
.height = static_cast<size_t>(target_height_)};
}
void ScrollingImageFrameGenerator::UpdateSourceFrame(size_t frame_num) {
VideoFrame::UpdateRect acc_update{0, 0, 0, 0};
while (current_frame_num_ != frame_num) {
current_source_frame_ = file_generator_.NextFrame();
if (current_source_frame_.update_rect) {
acc_update.Union(*current_source_frame_.update_rect);
}
current_frame_num_ = (current_frame_num_ + 1) % num_frames_;
}
current_source_frame_.update_rect = acc_update;
}
void ScrollingImageFrameGenerator::CropSourceToScrolledImage(
double scroll_factor) {
int scroll_margin_x = current_source_frame_.buffer->width() - target_width_;
int pixels_scrolled_x =
static_cast<int>(scroll_margin_x * scroll_factor + 0.5);
int scroll_margin_y = current_source_frame_.buffer->height() - target_height_;
int pixels_scrolled_y =
static_cast<int>(scroll_margin_y * scroll_factor + 0.5);
rtc::scoped_refptr<I420BufferInterface> i420_buffer =
current_source_frame_.buffer->ToI420();
int offset_y =
(i420_buffer->StrideY() * pixels_scrolled_y) + pixels_scrolled_x;
int offset_u = (i420_buffer->StrideU() * (pixels_scrolled_y / 2)) +
(pixels_scrolled_x / 2);
int offset_v = (i420_buffer->StrideV() * (pixels_scrolled_y / 2)) +
(pixels_scrolled_x / 2);
VideoFrame::UpdateRect update_rect =
current_source_frame_.update_rect->IsEmpty()
? VideoFrame::UpdateRect{0, 0, 0, 0}
: VideoFrame::UpdateRect{0, 0, target_width_, target_height_};
current_frame_ = VideoFrameData(
WrapI420Buffer(target_width_, target_height_,
&i420_buffer->DataY()[offset_y], i420_buffer->StrideY(),
&i420_buffer->DataU()[offset_u], i420_buffer->StrideU(),
&i420_buffer->DataV()[offset_v], i420_buffer->StrideV(),
// To keep reference alive.
[i420_buffer] {}),
update_rect);
}
} // namespace test
} // namespace webrtc