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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/390223051): Remove C-library calls to fix the errors.
#pragma allow_unsafe_libc_calls
#endif
#include "media/gpu/v4l2/v4l2_framerate_control.h"
#include <linux/videodev2.h>
#include "base/command_line.h"
#include "base/sequence_checker.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/sequenced_task_runner.h"
#include "base/trace_event/trace_event.h"
#include "media/base/media_switches.h"
namespace {
// Numerical value of ioctl() OK return value;
constexpr int kIoctlOk = 0;
double GetUserFrameRate() {
const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
if (!cmd_line->HasSwitch(switches::kHardwareVideoDecodeFrameRate))
return 0.0;
const std::string framerate_str(
cmd_line->GetSwitchValueASCII(switches::kHardwareVideoDecodeFrameRate));
constexpr double kMaxFramerate = 120.0;
double framerate = 0;
if (base::StringToDouble(framerate_str, &framerate) && framerate >= 0.0 &&
framerate <= kMaxFramerate) {
return framerate;
}
VLOG(1) << "Requested framerate is unreasonable: " << framerate
<< "fps, not overriding.";
return 0.0;
}
bool FrameRateControlPresent(
const media::V4L2FrameRateControl::IoctlAsCallback& ioctl_cb) {
struct v4l2_streamparm parms;
memset(&parms, 0, sizeof(parms));
parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
// Try to set the framerate to 30fps to see if the control is available.
// VIDIOC_G_PARM can not be used as it does not return the current
// framerate.
parms.parm.output.timeperframe.numerator = 1;
parms.parm.output.timeperframe.denominator = 30;
const double user_framerate = GetUserFrameRate();
if (user_framerate > 0.0) {
parms.parm.output.timeperframe.numerator = 1000;
parms.parm.output.timeperframe.denominator = 1000.0 * user_framerate;
VLOG(1) << "Overriding playback framerate. Set at " << user_framerate
<< " fps.";
}
if (ioctl_cb.Run(VIDIOC_S_PARM, &parms) != kIoctlOk) {
VLOG(1) << "Failed to issue VIDIOC_S_PARM command";
return false;
}
return (user_framerate == 0) &&
(parms.parm.output.capability & V4L2_CAP_TIMEPERFRAME);
}
} // namespace
namespace media {
static constexpr unsigned int kMovingAverageWindowSize = 32;
static constexpr base::TimeDelta kFrameIntervalFor120fps =
base::Milliseconds(8);
static constexpr base::TimeDelta kFrameIntervalFor24fps =
base::Milliseconds(41);
V4L2FrameRateControl::V4L2FrameRateControl(
const IoctlAsCallback& ioctl_cb,
scoped_refptr<base::SequencedTaskRunner> task_runner)
: ioctl_cb_(ioctl_cb),
framerate_control_present_(FrameRateControlPresent(ioctl_cb_)),
current_frame_duration_avg_ms_(0),
last_frame_display_time_(base::TimeTicks::Now()),
frame_duration_moving_average_(kMovingAverageWindowSize),
task_runner_(task_runner),
weak_this_factory_(this) {
DETACH_FROM_SEQUENCE(sequence_checker_);
}
V4L2FrameRateControl::~V4L2FrameRateControl() = default;
void V4L2FrameRateControl::UpdateFrameRate() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (frame_duration_moving_average_.Count() < kMovingAverageWindowSize) {
return;
}
const base::TimeDelta frame_duration_avg =
frame_duration_moving_average_.Mean();
if (frame_duration_avg > kFrameIntervalFor120fps &&
frame_duration_avg < kFrameIntervalFor24fps &&
frame_duration_avg.InMilliseconds() != current_frame_duration_avg_ms_) {
current_frame_duration_avg_ms_ = frame_duration_avg.InMilliseconds();
struct v4l2_streamparm parms;
memset(&parms, 0, sizeof(parms));
parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
parms.parm.output.timeperframe.numerator = current_frame_duration_avg_ms_;
parms.parm.output.timeperframe.denominator = 1000L;
TRACE_COUNTER_ID1("media,gpu", "V4L2 time per frame (ms)", this,
current_frame_duration_avg_ms_);
TRACE_COUNTER_ID1("media,gpu", "V4L2 estimated frame rate (Hz)", this,
std::round(frame_duration_avg.ToHz()));
if (ioctl_cb_.Run(VIDIOC_S_PARM, &parms) != kIoctlOk) {
LOG(ERROR) << "Failed to issue VIDIOC_S_PARM command";
TRACE_EVENT0("media,gpu", "V4L2 VIDIOC_S_PARM call failed");
}
DVLOG(4) << "Average framerate: " << frame_duration_avg.ToHz();
}
}
// static
void V4L2FrameRateControl::RecordFrameDurationThunk(
base::WeakPtr<V4L2FrameRateControl> weak_this,
scoped_refptr<base::SequencedTaskRunner> task_runner) {
if (task_runner->RunsTasksInCurrentSequence()) {
if (weak_this) {
weak_this->RecordFrameDuration();
}
} else {
task_runner->PostTask(
FROM_HERE,
base::BindOnce(&V4L2FrameRateControl::RecordFrameDuration, weak_this));
}
}
void V4L2FrameRateControl::RecordFrameDuration() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
constexpr base::TimeDelta kMaxFrameInterval = base::Milliseconds(500);
const base::TimeTicks frame_display_time = base::TimeTicks::Now();
const base::TimeDelta duration =
frame_display_time - last_frame_display_time_;
// Frames are expected to be returned at a consistent cadence because the
// durations are recorded after the frame is displayed, but this isn't always
// the case. If the video is not visible, then the frames will be returned
// as soon as they are decoded. The window needs to be large enough to
// handle this scenario. The video may also be paused, in which case there
// could be a large duration. In this case, reset the filter.
if (duration > kMaxFrameInterval)
frame_duration_moving_average_.Reset();
else
frame_duration_moving_average_.AddSample(duration);
last_frame_display_time_ = frame_display_time;
UpdateFrameRate();
}
void V4L2FrameRateControl::AttachToVideoFrame(
scoped_refptr<VideoFrame>& video_frame) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!framerate_control_present_)
return;
video_frame->AddDestructionObserver(
base::BindOnce(&V4L2FrameRateControl::RecordFrameDurationThunk,
weak_this_factory_.GetWeakPtr(), task_runner_));
}
void V4L2FrameRateControl::AttachToFrameResource(
scoped_refptr<FrameResource>& frame) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!framerate_control_present_) {
return;
}
frame->AddDestructionObserver(
base::BindOnce(&V4L2FrameRateControl::RecordFrameDurationThunk,
weak_this_factory_.GetWeakPtr(), task_runner_));
}
} // namespace media
|
