1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "remoting/test/cyclic_frame_generator.h"
#include <ostream>
#include "base/numerics/safe_conversions.h"
#include "base/time/default_tick_clock.h"
#include "remoting/test/frame_generator_util.h"
#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
namespace remoting {
namespace test {
CyclicFrameGenerator::ChangeInfo::ChangeInfo() = default;
CyclicFrameGenerator::ChangeInfo::ChangeInfo(ChangeType type,
base::TimeTicks timestamp)
: type(type), timestamp(timestamp) {}
// static
scoped_refptr<CyclicFrameGenerator> CyclicFrameGenerator::Create() {
std::vector<std::unique_ptr<webrtc::DesktopFrame>> frames;
frames.push_back(LoadDesktopFrameFromPng("test_frame1.png"));
frames.push_back(LoadDesktopFrameFromPng("test_frame2.png"));
return new CyclicFrameGenerator(std::move(frames));
}
CyclicFrameGenerator::CyclicFrameGenerator(
std::vector<std::unique_ptr<webrtc::DesktopFrame>> reference_frames)
: reference_frames_(std::move(reference_frames)),
clock_(base::DefaultTickClock::GetInstance()),
started_time_(clock_->NowTicks()) {
CHECK(!reference_frames_.empty());
screen_size_ = reference_frames_[0]->size();
for (const auto& frame : reference_frames_) {
CHECK(screen_size_.equals(frame->size()))
<< "All reference frames should have the same size.";
}
}
CyclicFrameGenerator::~CyclicFrameGenerator() = default;
void CyclicFrameGenerator::SetTickClock(const base::TickClock* tick_clock) {
clock_ = tick_clock;
started_time_ = clock_->NowTicks();
}
std::unique_ptr<webrtc::DesktopFrame> CyclicFrameGenerator::GenerateFrame(
webrtc::SharedMemoryFactory* shared_memory_factory) {
base::TimeTicks now = clock_->NowTicks();
int frame_id = base::ClampFloor((now - started_time_) / cursor_blink_period_);
int reference_frame =
base::ClampFloor((now - started_time_) / frame_cycle_period_) %
reference_frames_.size();
bool cursor_state = frame_id % 2;
auto frame = std::make_unique<webrtc::BasicDesktopFrame>(screen_size_);
frame->CopyPixelsFrom(*reference_frames_[reference_frame],
webrtc::DesktopVector(),
webrtc::DesktopRect::MakeSize(screen_size_));
// Render the cursor.
webrtc::DesktopRect cursor_rect =
webrtc::DesktopRect::MakeXYWH(20, 20, 2, 20);
if (cursor_state) {
DrawRect(frame.get(), cursor_rect, 0);
}
if (last_reference_frame_ != reference_frame) {
// The whole frame has changed.
frame->mutable_updated_region()->AddRect(
webrtc::DesktopRect::MakeSize(screen_size_));
last_frame_type_ = ChangeType::FULL;
} else if (last_cursor_state_ != cursor_state) {
// Cursor state has changed.
frame->mutable_updated_region()->AddRect(cursor_rect);
last_frame_type_ = ChangeType::CURSOR;
} else {
// No changes.
last_frame_type_ = ChangeType::NO_CHANGES;
}
last_reference_frame_ = reference_frame;
last_cursor_state_ = cursor_state;
return frame;
}
CyclicFrameGenerator::ChangeInfoList CyclicFrameGenerator::GetChangeList(
base::TimeTicks timestamp) {
int frame_id =
base::ClampFloor((timestamp - started_time_) / cursor_blink_period_);
CHECK_GE(frame_id, last_identifier_frame_);
ChangeInfoList result;
const int frames_in_cycle =
base::ClampFloor(frame_cycle_period_ / cursor_blink_period_);
for (int i = last_identifier_frame_ + 1; i <= frame_id; ++i) {
ChangeType type =
(i % frames_in_cycle == 0) ? ChangeType::FULL : ChangeType::CURSOR;
result.emplace_back(type, started_time_ + i * cursor_blink_period_);
}
last_identifier_frame_ = frame_id;
return result;
}
protocol::InputEventTimestamps CyclicFrameGenerator::TakeLastEventTimestamps() {
base::TimeTicks now = clock_->NowTicks();
return protocol::InputEventTimestamps{now, now};
}
} // namespace test
} // namespace remoting
|
