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
|
/*
* Copyright 2019 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 "rtc_base/experiments/min_video_bitrate_experiment.h"
#include <cstdio>
#include <optional>
#include <string>
#include "api/field_trials_view.h"
#include "api/units/data_rate.h"
#include "api/video/video_codec_type.h"
#include "rtc_base/checks.h"
#include "rtc_base/experiments/field_trial_parser.h"
#include "rtc_base/logging.h"
namespace webrtc {
const int kDefaultMinVideoBitrateBps = 30000;
namespace {
const char kForcedFallbackFieldTrial[] =
"WebRTC-VP8-Forced-Fallback-Encoder-v2";
const char kMinVideoBitrateExperiment[] = "WebRTC-Video-MinVideoBitrate";
std::optional<int> GetFallbackMinBpsFromFieldTrial(
const FieldTrialsView& field_trials,
VideoCodecType type) {
if (type != kVideoCodecVP8) {
return std::nullopt;
}
if (!field_trials.IsEnabled(kForcedFallbackFieldTrial)) {
return std::nullopt;
}
const std::string group = field_trials.Lookup(kForcedFallbackFieldTrial);
if (group.empty()) {
return std::nullopt;
}
int min_pixels; // Ignored.
int max_pixels; // Ignored.
int min_bps;
if (sscanf(group.c_str(), "Enabled-%d,%d,%d", &min_pixels, &max_pixels,
&min_bps) != 3) {
return std::nullopt;
}
if (min_bps <= 0) {
return std::nullopt;
}
return min_bps;
}
} // namespace
std::optional<DataRate> GetExperimentalMinVideoBitrate(
const FieldTrialsView& field_trials,
VideoCodecType type) {
const std::optional<int> fallback_min_bitrate_bps =
GetFallbackMinBpsFromFieldTrial(field_trials, type);
if (fallback_min_bitrate_bps) {
return DataRate::BitsPerSec(*fallback_min_bitrate_bps);
}
if (field_trials.IsEnabled(kMinVideoBitrateExperiment)) {
FieldTrialFlag enabled("Enabled");
// Backwards-compatibility with an old experiment - a generic minimum which,
// if set, applies to all codecs.
FieldTrialOptional<DataRate> min_video_bitrate("br");
// New experiment - per-codec minimum bitrate.
FieldTrialOptional<DataRate> min_bitrate_vp8("vp8_br");
FieldTrialOptional<DataRate> min_bitrate_vp9("vp9_br");
FieldTrialOptional<DataRate> min_bitrate_av1("av1_br");
FieldTrialOptional<DataRate> min_bitrate_h264("h264_br");
ParseFieldTrial({&enabled, &min_video_bitrate, &min_bitrate_vp8,
&min_bitrate_vp9, &min_bitrate_av1, &min_bitrate_h264},
field_trials.Lookup(kMinVideoBitrateExperiment));
if (min_video_bitrate) {
if (min_bitrate_vp8 || min_bitrate_vp9 || min_bitrate_av1 ||
min_bitrate_h264) {
// "br" is mutually-exclusive with the other configuration possibilites.
RTC_LOG(LS_WARNING) << "Self-contradictory experiment config.";
}
return *min_video_bitrate;
}
switch (type) {
case kVideoCodecVP8:
return min_bitrate_vp8.GetOptional();
case kVideoCodecH265:
// TODO(bugs.webrtc.org/13485): Use VP9 bitrate limits for now.
case kVideoCodecVP9:
return min_bitrate_vp9.GetOptional();
case kVideoCodecAV1:
return min_bitrate_av1.GetOptional();
case kVideoCodecH264:
return min_bitrate_h264.GetOptional();
case kVideoCodecGeneric:
return std::nullopt;
}
RTC_DCHECK_NOTREACHED();
}
return std::nullopt;
}
} // namespace webrtc
|
