blob: a77706a3f11fbd3c41f5e4016f8c143e439cf358 (
plain)
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
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef REMOTING_TEST_CYCLIC_FRAME_GENERATOR_H_
#define REMOTING_TEST_CYCLIC_FRAME_GENERATOR_H_
#include <map>
#include <vector>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/time/default_tick_clock.h"
#include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
namespace remoting {
namespace test {
// CyclicFrameGenerator generates a sequence of frames that approximates
// properties of a real video stream when using a desktop applications. It
// loads a sequence of reference frames and switches between them with the
// specified frequency (every 2 seconds by default). Between reference frames it
// also generate frames with small changes which simulate a blinking cursor.
class CyclicFrameGenerator
: public base::RefCountedThreadSafe<CyclicFrameGenerator> {
public:
enum class FrameType {
// Frame had no changes.
EMPTY,
// Whole screen changed.
FULL,
// Cursor state has changed.
CURSOR,
};
struct FrameInfo {
FrameInfo();
FrameInfo(int frame_id, FrameType type, base::TimeTicks timestamp);
int frame_id = 0;
FrameType type = FrameType::EMPTY;
base::TimeTicks timestamp;
};
static scoped_refptr<CyclicFrameGenerator> Create();
CyclicFrameGenerator(
std::vector<scoped_ptr<webrtc::DesktopFrame>> reference_frames);
void set_frame_cycle_period(base::TimeDelta frame_cycle_period) {
frame_cycle_period_ = frame_cycle_period;
}
void set_cursor_blink_period(base::TimeDelta cursor_blink_period) {
cursor_blink_period_ = cursor_blink_period;
}
void SetTickClock(base::TickClock* tick_clock);
// When |draw_barcode| is set to true a barcode is drawn on each generated
// frame. This make it possible to call IdentifyFrame() to identify the frame
// by its content.
void set_draw_barcode(bool draw_barcode) { draw_barcode_ = draw_barcode; }
scoped_ptr<webrtc::DesktopFrame> GenerateFrame(
webrtc::SharedMemoryFactory* shared_memory_factory);
FrameType last_frame_type() { return last_frame_type_; }
// Identifies |frame| by its content and returns FrameInfo corresponding to
// the frame.
FrameInfo IdentifyFrame(webrtc::DesktopFrame* frame);
private:
~CyclicFrameGenerator();
friend class base::RefCountedThreadSafe<CyclicFrameGenerator>;
std::vector<scoped_ptr<webrtc::DesktopFrame>> reference_frames_;
base::DefaultTickClock default_tick_clock_;
base::TickClock* clock_;
webrtc::DesktopSize screen_size_;
// By default switch between reference frames every 2 seconds.
base::TimeDelta frame_cycle_period_ = base::TimeDelta::FromSeconds(2);
// By default blink the cursor 4 times per seconds.
base::TimeDelta cursor_blink_period_ = base::TimeDelta::FromMilliseconds(250);
// Id of the last frame encoded on the barcode.
int last_frame_id_ = -1;
// Index of the reference frame used to render the last generated frame.
int last_reference_frame_ = -1;
// True if the cursor was rendered on the last generated frame.
bool last_cursor_state_ = false;
FrameType last_frame_type_ = FrameType::EMPTY;
bool draw_barcode_ = false;
base::TimeTicks started_time_;
std::map<int, FrameInfo> generated_frames_info_;
DISALLOW_COPY_AND_ASSIGN(CyclicFrameGenerator);
};
} // namespace test
} // namespace remoting
#endif // REMOTING_TEST_CYCLIC_FRAME_GENERATOR_H_
|
