1 /*
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10 #include "test/encoder_settings.h"
11
12 #include <algorithm>
13 #include <string>
14
15 #include "api/scoped_refptr.h"
16 #include "api/video_codecs/sdp_video_format.h"
17 #include "call/rtp_config.h"
18 #include "rtc_base/checks.h"
19 #include "rtc_base/ref_counted_object.h"
20
21 namespace webrtc {
22 namespace test {
23
24 const size_t DefaultVideoStreamFactory::kMaxNumberOfStreams;
25 const int DefaultVideoStreamFactory::kMaxBitratePerStream[] = {150000, 450000,
26 1500000};
27 const int DefaultVideoStreamFactory::kDefaultMinBitratePerStream[] = {
28 30000, 200000, 700000};
29
30 // static
CreateVideoStreams(int width,int height,const webrtc::VideoEncoderConfig & encoder_config)31 std::vector<VideoStream> CreateVideoStreams(
32 int width,
33 int height,
34 const webrtc::VideoEncoderConfig& encoder_config) {
35 RTC_DCHECK(encoder_config.number_of_streams <=
36 DefaultVideoStreamFactory::kMaxNumberOfStreams);
37
38 std::vector<VideoStream> stream_settings(encoder_config.number_of_streams);
39
40 int bitrate_left_bps = 0;
41 if (encoder_config.max_bitrate_bps > 0) {
42 bitrate_left_bps = encoder_config.max_bitrate_bps;
43 } else {
44 for (size_t stream_num = 0; stream_num < encoder_config.number_of_streams;
45 ++stream_num) {
46 bitrate_left_bps +=
47 DefaultVideoStreamFactory::kMaxBitratePerStream[stream_num];
48 }
49 }
50
51 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
52 stream_settings[i].width =
53 (i + 1) * width / encoder_config.number_of_streams;
54 stream_settings[i].height =
55 (i + 1) * height / encoder_config.number_of_streams;
56 stream_settings[i].max_framerate = 30;
57 stream_settings[i].min_bitrate_bps =
58 DefaultVideoStreamFactory::kDefaultMinBitratePerStream[i];
59
60 int target_bitrate_bps = -1;
61 int max_bitrate_bps = -1;
62 // Use configured values instead of default values if values has been
63 // configured.
64 if (i < encoder_config.simulcast_layers.size()) {
65 const VideoStream& stream = encoder_config.simulcast_layers[i];
66
67 max_bitrate_bps =
68 stream.max_bitrate_bps > 0
69 ? stream.max_bitrate_bps
70 : DefaultVideoStreamFactory::kMaxBitratePerStream[i];
71 max_bitrate_bps = std::min(bitrate_left_bps, max_bitrate_bps);
72
73 target_bitrate_bps =
74 stream.target_bitrate_bps > 0
75 ? stream.target_bitrate_bps
76 : DefaultVideoStreamFactory::kMaxBitratePerStream[i];
77 target_bitrate_bps = std::min(max_bitrate_bps, target_bitrate_bps);
78
79 if (stream.min_bitrate_bps > 0) {
80 RTC_DCHECK_LE(stream.min_bitrate_bps, target_bitrate_bps);
81 stream_settings[i].min_bitrate_bps = stream.min_bitrate_bps;
82 }
83 if (stream.max_framerate > 0) {
84 stream_settings[i].max_framerate = stream.max_framerate;
85 }
86 if (stream.num_temporal_layers) {
87 RTC_DCHECK_GE(*stream.num_temporal_layers, 1);
88 stream_settings[i].num_temporal_layers = stream.num_temporal_layers;
89 }
90 if (stream.scale_resolution_down_by >= 1.0) {
91 stream_settings[i].width = width / stream.scale_resolution_down_by;
92 stream_settings[i].height = height / stream.scale_resolution_down_by;
93 }
94 } else {
95 max_bitrate_bps = std::min(
96 bitrate_left_bps, DefaultVideoStreamFactory::kMaxBitratePerStream[i]);
97 target_bitrate_bps = max_bitrate_bps;
98 }
99
100 RTC_DCHECK_NE(target_bitrate_bps, -1);
101 RTC_DCHECK_NE(max_bitrate_bps, -1);
102 stream_settings[i].target_bitrate_bps = target_bitrate_bps;
103 stream_settings[i].max_bitrate_bps = max_bitrate_bps;
104 stream_settings[i].max_qp = 56;
105
106 if (i < encoder_config.simulcast_layers.size()) {
107 // Higher level controls are setting the active configuration for the
108 // VideoStream.
109 stream_settings[i].active = encoder_config.simulcast_layers[i].active;
110 } else {
111 stream_settings[i].active = true;
112 }
113 bitrate_left_bps -= stream_settings[i].target_bitrate_bps;
114 }
115
116 stream_settings[encoder_config.number_of_streams - 1].max_bitrate_bps +=
117 bitrate_left_bps;
118 stream_settings[0].bitrate_priority = encoder_config.bitrate_priority;
119
120 return stream_settings;
121 }
122
DefaultVideoStreamFactory()123 DefaultVideoStreamFactory::DefaultVideoStreamFactory() {}
124
CreateEncoderStreams(int width,int height,const webrtc::VideoEncoderConfig & encoder_config)125 std::vector<VideoStream> DefaultVideoStreamFactory::CreateEncoderStreams(
126 int width,
127 int height,
128 const webrtc::VideoEncoderConfig& encoder_config) {
129 return CreateVideoStreams(width, height, encoder_config);
130 }
131
FillEncoderConfiguration(VideoCodecType codec_type,size_t num_streams,VideoEncoderConfig * configuration)132 void FillEncoderConfiguration(VideoCodecType codec_type,
133 size_t num_streams,
134 VideoEncoderConfig* configuration) {
135 RTC_DCHECK_LE(num_streams, DefaultVideoStreamFactory::kMaxNumberOfStreams);
136
137 configuration->codec_type = codec_type;
138 configuration->number_of_streams = num_streams;
139 configuration->video_stream_factory =
140 new rtc::RefCountedObject<DefaultVideoStreamFactory>();
141 configuration->max_bitrate_bps = 0;
142 configuration->simulcast_layers = std::vector<VideoStream>(num_streams);
143 for (size_t i = 0; i < num_streams; ++i) {
144 configuration->max_bitrate_bps +=
145 DefaultVideoStreamFactory::kMaxBitratePerStream[i];
146 }
147 }
148
CreateMatchingDecoder(int payload_type,const std::string & payload_name)149 VideoReceiveStream::Decoder CreateMatchingDecoder(
150 int payload_type,
151 const std::string& payload_name) {
152 VideoReceiveStream::Decoder decoder;
153 decoder.payload_type = payload_type;
154 decoder.video_format = SdpVideoFormat(payload_name);
155 return decoder;
156 }
157
CreateMatchingDecoder(const VideoSendStream::Config & config)158 VideoReceiveStream::Decoder CreateMatchingDecoder(
159 const VideoSendStream::Config& config) {
160 return CreateMatchingDecoder(config.rtp.payload_type,
161 config.rtp.payload_name);
162 }
163
164 } // namespace test
165 } // namespace webrtc
166