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
14 #include "api/scoped_refptr.h"
15 #include "api/video_codecs/sdp_video_format.h"
16 #include "call/rtp_config.h"
17 #include "rtc_base/checks.h"
18
19 namespace webrtc {
20 namespace test {
21
22 const size_t DefaultVideoStreamFactory::kMaxNumberOfStreams;
23 const int DefaultVideoStreamFactory::kMaxBitratePerStream[] = {150000, 450000,
24 1500000};
25 const int DefaultVideoStreamFactory::kDefaultMinBitratePerStream[] = {
26 30000, 200000, 700000};
27
28 // static
CreateVideoStreams(int width,int height,const webrtc::VideoEncoderConfig & encoder_config)29 std::vector<VideoStream> CreateVideoStreams(
30 int width,
31 int height,
32 const webrtc::VideoEncoderConfig& encoder_config) {
33 RTC_DCHECK(encoder_config.number_of_streams <=
34 DefaultVideoStreamFactory::kMaxNumberOfStreams);
35
36 std::vector<VideoStream> stream_settings(encoder_config.number_of_streams);
37
38 int bitrate_left_bps = 0;
39 if (encoder_config.max_bitrate_bps > 0) {
40 bitrate_left_bps = encoder_config.max_bitrate_bps;
41 } else {
42 for (size_t stream_num = 0; stream_num < encoder_config.number_of_streams;
43 ++stream_num) {
44 bitrate_left_bps +=
45 DefaultVideoStreamFactory::kMaxBitratePerStream[stream_num];
46 }
47 }
48
49 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
50 stream_settings[i].width =
51 (i + 1) * width / encoder_config.number_of_streams;
52 stream_settings[i].height =
53 (i + 1) * height / encoder_config.number_of_streams;
54 stream_settings[i].max_framerate = 30;
55 stream_settings[i].max_qp = 56;
56 stream_settings[i].min_bitrate_bps =
57 DefaultVideoStreamFactory::kDefaultMinBitratePerStream[i];
58
59 // Use configured values instead of default values if set.
60 const VideoStream stream = (i < encoder_config.simulcast_layers.size())
61 ? encoder_config.simulcast_layers[i]
62 : VideoStream();
63
64 int max_bitrate_bps =
65 stream.max_bitrate_bps > 0
66 ? stream.max_bitrate_bps
67 : DefaultVideoStreamFactory::kMaxBitratePerStream[i];
68 max_bitrate_bps = std::min(bitrate_left_bps, max_bitrate_bps);
69
70 int target_bitrate_bps = stream.target_bitrate_bps > 0
71 ? stream.target_bitrate_bps
72 : max_bitrate_bps;
73 target_bitrate_bps = std::min(max_bitrate_bps, target_bitrate_bps);
74
75 if (stream.min_bitrate_bps > 0) {
76 RTC_DCHECK_LE(stream.min_bitrate_bps, target_bitrate_bps);
77 stream_settings[i].min_bitrate_bps = stream.min_bitrate_bps;
78 }
79 if (stream.max_framerate > 0) {
80 stream_settings[i].max_framerate = stream.max_framerate;
81 }
82 if (stream.num_temporal_layers) {
83 RTC_DCHECK_GE(*stream.num_temporal_layers, 1);
84 stream_settings[i].num_temporal_layers = stream.num_temporal_layers;
85 }
86 if (stream.scale_resolution_down_by >= 1.0) {
87 stream_settings[i].width = width / stream.scale_resolution_down_by;
88 stream_settings[i].height = height / stream.scale_resolution_down_by;
89 }
90 stream_settings[i].scalability_mode = stream.scalability_mode;
91 stream_settings[i].target_bitrate_bps = target_bitrate_bps;
92 stream_settings[i].max_bitrate_bps = max_bitrate_bps;
93 stream_settings[i].active =
94 encoder_config.number_of_streams == 1 || stream.active;
95
96 bitrate_left_bps -= stream_settings[i].target_bitrate_bps;
97 }
98
99 stream_settings[encoder_config.number_of_streams - 1].max_bitrate_bps +=
100 bitrate_left_bps;
101 stream_settings[0].bitrate_priority = encoder_config.bitrate_priority;
102
103 return stream_settings;
104 }
105
DefaultVideoStreamFactory()106 DefaultVideoStreamFactory::DefaultVideoStreamFactory() {}
107
CreateEncoderStreams(int frame_width,int frame_height,const webrtc::VideoEncoderConfig & encoder_config)108 std::vector<VideoStream> DefaultVideoStreamFactory::CreateEncoderStreams(
109 int frame_width,
110 int frame_height,
111 const webrtc::VideoEncoderConfig& encoder_config) {
112 return CreateVideoStreams(frame_width, frame_height, encoder_config);
113 }
114
FillEncoderConfiguration(VideoCodecType codec_type,size_t num_streams,VideoEncoderConfig * configuration)115 void FillEncoderConfiguration(VideoCodecType codec_type,
116 size_t num_streams,
117 VideoEncoderConfig* configuration) {
118 RTC_DCHECK_LE(num_streams, DefaultVideoStreamFactory::kMaxNumberOfStreams);
119
120 configuration->codec_type = codec_type;
121 configuration->number_of_streams = num_streams;
122 configuration->video_stream_factory =
123 rtc::make_ref_counted<DefaultVideoStreamFactory>();
124 configuration->max_bitrate_bps = 0;
125 configuration->frame_drop_enabled = true;
126 configuration->simulcast_layers = std::vector<VideoStream>(num_streams);
127 for (size_t i = 0; i < num_streams; ++i) {
128 configuration->max_bitrate_bps +=
129 DefaultVideoStreamFactory::kMaxBitratePerStream[i];
130 }
131 }
132
CreateMatchingDecoder(int payload_type,const std::string & payload_name)133 VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
134 int payload_type,
135 const std::string& payload_name) {
136 VideoReceiveStreamInterface::Decoder decoder;
137 decoder.payload_type = payload_type;
138 decoder.video_format = SdpVideoFormat(payload_name);
139 return decoder;
140 }
141
CreateMatchingDecoder(const VideoSendStream::Config & config)142 VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
143 const VideoSendStream::Config& config) {
144 return CreateMatchingDecoder(config.rtp.payload_type,
145 config.rtp.payload_name);
146 }
147
148 } // namespace test
149 } // namespace webrtc
150