OLD | NEW |
---|---|
(Empty) | |
1 /* | |
2 * Copyright 2017 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 | |
11 #include "webrtc/rtc_base/bitrateallocationstrategy.h" | |
12 #include <algorithm> | |
13 #include <utility> | |
14 | |
15 namespace rtc { | |
16 | |
17 std::vector<uint32_t> BitrateAllocationStrategy::SetAllBitratesToMinimum( | |
18 const ArrayView<const TrackConfig*> track_configs) { | |
19 std::vector<uint32_t> track_allocations; | |
20 for (const auto* track_config : track_configs) { | |
21 track_allocations.push_back(track_config->min_bitrate_bps); | |
22 } | |
23 return track_allocations; | |
24 } | |
25 | |
26 std::vector<uint32_t> BitrateAllocationStrategy::DistributeBitratesEvenly( | |
27 const ArrayView<const TrackConfig*> track_configs, | |
28 uint32_t available_bitrate) { | |
29 std::vector<uint32_t> track_allocations = | |
30 SetAllBitratesToMinimum(track_configs); | |
31 uint32_t sum_min_bitrates = 0; | |
32 uint32_t sum_max_bitrates = 0; | |
33 for (const auto* track_config : track_configs) { | |
34 sum_min_bitrates += track_config->min_bitrate_bps; | |
35 sum_max_bitrates += track_config->max_bitrate_bps; | |
36 } | |
37 if (sum_min_bitrates >= available_bitrate) { | |
38 return track_allocations; | |
39 } else if (available_bitrate >= sum_max_bitrates) { | |
40 auto track_allocations_it = track_allocations.begin(); | |
41 for (const auto* track_config : track_configs) { | |
42 *track_allocations_it++ = track_config->max_bitrate_bps; | |
43 } | |
44 return track_allocations; | |
Taylor Brandstetter
2017/09/11 16:55:06
Where is "enforce_min_bitrate" used?
alexnarest
2017/09/14 13:08:33
Current implementation does not pause tracks.
Taylor Brandstetter
2017/09/15 01:24:41
Should that be documented in a comment?
alexnarest
2017/09/15 08:29:38
Done.
| |
45 } else { | |
46 std::multimap<uint32_t, size_t> max_bitrate_sorted_configs; | |
Taylor Brandstetter
2017/09/11 16:55:06
This logic is a little confusing at first glance;
alexnarest
2017/09/14 13:08:33
Done.
| |
47 for (const TrackConfig** track_configs_it = track_configs.begin(); | |
48 track_configs_it != track_configs.end(); track_configs_it++) { | |
49 max_bitrate_sorted_configs.insert(std::pair<uint32_t, size_t>( | |
50 (*track_configs_it)->max_bitrate_bps, | |
51 track_configs_it - track_configs.begin())); | |
52 } | |
53 uint32_t total_available_increase = (available_bitrate - sum_min_bitrates); | |
54 int processed_configs = 0; | |
55 for (const auto& track_config_pair : max_bitrate_sorted_configs) { | |
56 uint32_t available_increase = | |
57 total_available_increase / | |
58 (static_cast<uint32_t>(track_configs.size() - processed_configs)); | |
59 uint32_t consumed_increase = | |
60 std::min(track_configs[track_config_pair.second]->max_bitrate_bps - | |
61 track_configs[track_config_pair.second]->min_bitrate_bps, | |
62 available_increase); | |
63 track_allocations[track_config_pair.second] += consumed_increase; | |
64 total_available_increase -= consumed_increase; | |
65 ++processed_configs; | |
66 } | |
67 return track_allocations; | |
68 } | |
69 } | |
70 | |
71 AudioPriorityBitrateAllocationStrategy::AudioPriorityBitrateAllocationStrategy( | |
72 std::string audio_track_id, | |
73 uint32_t sufficient_audio_bitrate) | |
74 : audio_track_id_(audio_track_id), | |
75 sufficient_audio_bitrate_(sufficient_audio_bitrate) {} | |
76 | |
77 std::vector<uint32_t> AudioPriorityBitrateAllocationStrategy::AllocateBitrates( | |
78 uint32_t available_bitrate, | |
79 const ArrayView<const TrackConfig*> track_configs) { | |
80 const TrackConfig* audio_track_config = NULL; | |
81 size_t audio_config_index = -1; | |
82 uint32_t sum_min_bitrates = 0; | |
83 | |
84 for (auto*& track_config : track_configs) { | |
85 sum_min_bitrates += track_config->min_bitrate_bps; | |
86 if (track_config->track_id == audio_track_id_) { | |
87 audio_track_config = track_config; | |
88 audio_config_index = &track_config - &track_configs[0]; | |
89 } | |
90 } | |
91 if (audio_track_config == NULL) { | |
92 return DistributeBitratesEvenly(track_configs, available_bitrate); | |
93 } | |
94 RTC_DCHECK(sufficient_audio_bitrate_ >= audio_track_config->min_bitrate_bps && | |
95 sufficient_audio_bitrate_ <= audio_track_config->max_bitrate_bps); | |
Taylor Brandstetter
2017/09/11 16:55:06
Is it possible that this DCHECK could be hit due t
alexnarest
2017/09/14 13:08:33
Done.
| |
96 if (available_bitrate <= sum_min_bitrates) { | |
97 return SetAllBitratesToMinimum(track_configs); | |
98 } else { | |
99 if (available_bitrate <= sum_min_bitrates + sufficient_audio_bitrate_ - | |
100 audio_track_config->min_bitrate_bps) { | |
101 std::vector<uint32_t> track_allocations = | |
102 SetAllBitratesToMinimum(track_configs); | |
103 track_allocations[audio_config_index] += | |
104 available_bitrate - sum_min_bitrates; | |
105 return track_allocations; | |
106 } else { | |
107 const TrackConfig* saved_track_config = track_configs[audio_config_index]; | |
108 TrackConfig sufficient_track_config(*track_configs[audio_config_index]); | |
109 sufficient_track_config.min_bitrate_bps = sufficient_audio_bitrate_; | |
110 track_configs[audio_config_index] = &sufficient_track_config; | |
111 std::vector<uint32_t> track_allocations = | |
112 DistributeBitratesEvenly(track_configs, available_bitrate); | |
113 track_configs[audio_config_index] = saved_track_config; | |
114 return track_allocations; | |
115 } | |
116 } | |
117 } | |
118 | |
119 } // namespace rtc | |
OLD | NEW |