OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 #include "webrtc/test/encoder_settings.h" | 10 #include "webrtc/test/encoder_settings.h" |
11 | 11 |
12 #include <algorithm> | 12 #include <assert.h> |
13 #include <string> | 13 #include <string.h> |
14 | 14 |
15 #include "webrtc/test/fake_decoder.h" | 15 #include "webrtc/test/fake_decoder.h" |
16 #include "webrtc/video_decoder.h" | 16 #include "webrtc/video_decoder.h" |
17 | 17 |
18 namespace webrtc { | 18 namespace webrtc { |
19 namespace test { | 19 namespace test { |
| 20 std::vector<VideoStream> CreateVideoStreams(size_t num_streams) { |
| 21 assert(num_streams > 0); |
20 | 22 |
21 const size_t DefaultVideoStreamFactory::kMaxNumberOfStreams; | 23 // Add more streams to the settings above with reasonable values if required. |
22 const int DefaultVideoStreamFactory::kMaxBitratePerStream[] = {150000, 450000, | 24 static const size_t kNumSettings = 3; |
23 1500000}; | 25 assert(num_streams <= kNumSettings); |
24 const int DefaultVideoStreamFactory::kDefaultMinBitratePerStream[] = { | |
25 50000, 200000, 700000}; | |
26 | 26 |
27 // static | 27 std::vector<VideoStream> stream_settings(kNumSettings); |
28 std::vector<VideoStream> CreateVideoStreams( | |
29 int width, | |
30 int height, | |
31 const webrtc::VideoEncoderConfig& encoder_config) { | |
32 RTC_DCHECK(encoder_config.number_of_streams <= | |
33 DefaultVideoStreamFactory::kMaxNumberOfStreams); | |
34 | 28 |
35 std::vector<VideoStream> stream_settings(encoder_config.number_of_streams); | 29 stream_settings[0].width = 320; |
36 int bitrate_left_bps = encoder_config.max_bitrate_bps; | 30 stream_settings[0].height = 180; |
| 31 stream_settings[0].max_framerate = 30; |
| 32 stream_settings[0].min_bitrate_bps = 50000; |
| 33 stream_settings[0].target_bitrate_bps = stream_settings[0].max_bitrate_bps = |
| 34 150000; |
| 35 stream_settings[0].max_qp = 56; |
37 | 36 |
38 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) { | 37 stream_settings[1].width = 640; |
39 stream_settings[i].width = | 38 stream_settings[1].height = 360; |
40 (i + 1) * width / encoder_config.number_of_streams; | 39 stream_settings[1].max_framerate = 30; |
41 stream_settings[i].height = | 40 stream_settings[1].min_bitrate_bps = 200000; |
42 (i + 1) * height / encoder_config.number_of_streams; | 41 stream_settings[1].target_bitrate_bps = stream_settings[1].max_bitrate_bps = |
43 stream_settings[i].max_framerate = 30; | 42 450000; |
44 stream_settings[i].min_bitrate_bps = | 43 stream_settings[1].max_qp = 56; |
45 DefaultVideoStreamFactory::kDefaultMinBitratePerStream[i]; | |
46 stream_settings[i].target_bitrate_bps = stream_settings[i].max_bitrate_bps = | |
47 std::min(bitrate_left_bps, | |
48 DefaultVideoStreamFactory::kMaxBitratePerStream[i]); | |
49 stream_settings[i].max_qp = 56; | |
50 bitrate_left_bps -= stream_settings[i].target_bitrate_bps; | |
51 } | |
52 | 44 |
53 stream_settings[encoder_config.number_of_streams - 1].max_bitrate_bps += | 45 stream_settings[2].width = 1280; |
54 bitrate_left_bps; | 46 stream_settings[2].height = 720; |
55 | 47 stream_settings[2].max_framerate = 30; |
| 48 stream_settings[2].min_bitrate_bps = 700000; |
| 49 stream_settings[2].target_bitrate_bps = stream_settings[2].max_bitrate_bps = |
| 50 1500000; |
| 51 stream_settings[2].max_qp = 56; |
| 52 stream_settings.resize(num_streams); |
56 return stream_settings; | 53 return stream_settings; |
57 } | 54 } |
58 | 55 |
59 DefaultVideoStreamFactory::DefaultVideoStreamFactory() {} | |
60 | |
61 std::vector<VideoStream> DefaultVideoStreamFactory::CreateEncoderStreams( | |
62 int width, | |
63 int height, | |
64 const webrtc::VideoEncoderConfig& encoder_config) { | |
65 return CreateVideoStreams(width, height, encoder_config); | |
66 } | |
67 | |
68 void FillEncoderConfiguration(size_t num_streams, | |
69 VideoEncoderConfig* configuration) { | |
70 RTC_DCHECK_LE(num_streams, DefaultVideoStreamFactory::kMaxNumberOfStreams); | |
71 | |
72 configuration->number_of_streams = num_streams; | |
73 configuration->video_stream_factory = | |
74 new rtc::RefCountedObject<DefaultVideoStreamFactory>(); | |
75 configuration->max_bitrate_bps = 0; | |
76 for (size_t i = 0; i < num_streams; ++i) { | |
77 configuration->max_bitrate_bps += | |
78 DefaultVideoStreamFactory::kMaxBitratePerStream[i]; | |
79 } | |
80 } | |
81 | |
82 VideoReceiveStream::Decoder CreateMatchingDecoder( | 56 VideoReceiveStream::Decoder CreateMatchingDecoder( |
83 const VideoSendStream::Config::EncoderSettings& encoder_settings) { | 57 const VideoSendStream::Config::EncoderSettings& encoder_settings) { |
84 VideoReceiveStream::Decoder decoder; | 58 VideoReceiveStream::Decoder decoder; |
85 decoder.payload_type = encoder_settings.payload_type; | 59 decoder.payload_type = encoder_settings.payload_type; |
86 decoder.payload_name = encoder_settings.payload_name; | 60 decoder.payload_name = encoder_settings.payload_name; |
87 if (encoder_settings.payload_name == "H264") { | 61 if (encoder_settings.payload_name == "H264") { |
88 decoder.decoder = VideoDecoder::Create(VideoDecoder::kH264); | 62 decoder.decoder = VideoDecoder::Create(VideoDecoder::kH264); |
89 } else if (encoder_settings.payload_name == "VP8") { | 63 } else if (encoder_settings.payload_name == "VP8") { |
90 decoder.decoder = VideoDecoder::Create(VideoDecoder::kVp8); | 64 decoder.decoder = VideoDecoder::Create(VideoDecoder::kVp8); |
91 } else if (encoder_settings.payload_name == "VP9") { | 65 } else if (encoder_settings.payload_name == "VP9") { |
92 decoder.decoder = VideoDecoder::Create(VideoDecoder::kVp9); | 66 decoder.decoder = VideoDecoder::Create(VideoDecoder::kVp9); |
93 } else { | 67 } else { |
94 decoder.decoder = new FakeDecoder(); | 68 decoder.decoder = new FakeDecoder(); |
95 } | 69 } |
96 return decoder; | 70 return decoder; |
97 } | 71 } |
98 } // namespace test | 72 } // namespace test |
99 } // namespace webrtc | 73 } // namespace webrtc |
OLD | NEW |