zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add kTransmissionMaxBitrateMultiplier logic to audio priority bitrate allocation strategy similarly to default bitrate allocation logic.

Browse Source 
Bug: webrtc:8243
Change-Id: I128712ae96cc13ace0c6d2edf518eb59d30a4569
Reviewed-on: https://webrtc-review.googlesource.com/21983
Commit-Queue: Alex Narest <alexnarest@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20722}
This commit is contained in:
Alex Narest
2017-11-16 20:03:46 +01:00
committed by Commit Bot
parent 32026c3078
commit e0b2ff5ea4
2 changed files with 30 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
call/bitrate_allocator.cc
View File

@ -26,6 +26,9 @@ namespace webrtc {
// Allow packets to be transmitted in up to 2 times max video bitrate if the // Allow packets to be transmitted in up to 2 times max video bitrate if the
// bandwidth estimate allows it. // bandwidth estimate allows it.
// TODO(bugs.webrtc.org/8541): May be worth to refactor to keep this logic in
// video send stream. Similar logic is implemented in
// AudioPriorityBitrateAllocationStrategy.
const int kTransmissionMaxBitrateMultiplier = 2; const int kTransmissionMaxBitrateMultiplier = 2;
const int kDefaultBitrateBps = 300000; const int kDefaultBitrateBps = 300000;

27
rtc_base/bitrateallocationstrategy.cc
View File

@ -14,6 +14,12 @@
namespace rtc { namespace rtc {
// The purpose of this is to allow video streams to use extra bandwidth for FEC.
// TODO(bugs.webrtc.org/8541): May be worth to refactor to keep this logic in
// video send stream. Similar logic is implemented in BitrateAllocator.
const int kTransmissionMaxBitrateMultiplier = 2;
std::vector<uint32_t> BitrateAllocationStrategy::SetAllBitratesToMinimum( std::vector<uint32_t> BitrateAllocationStrategy::SetAllBitratesToMinimum(
const ArrayView<const TrackConfig*> track_configs) { const ArrayView<const TrackConfig*> track_configs) {
std::vector<uint32_t> track_allocations; std::vector<uint32_t> track_allocations;
@ -84,14 +90,35 @@ std::vector<uint32_t> AudioPriorityBitrateAllocationStrategy::AllocateBitrates(
const TrackConfig* audio_track_config = NULL; const TrackConfig* audio_track_config = NULL;
size_t audio_config_index = 0; size_t audio_config_index = 0;
uint32_t sum_min_bitrates = 0; uint32_t sum_min_bitrates = 0;
uint32_t sum_max_bitrates = 0;
for (const auto*& track_config : track_configs) { for (const auto*& track_config : track_configs) {
sum_min_bitrates += track_config->min_bitrate_bps; sum_min_bitrates += track_config->min_bitrate_bps;
sum_max_bitrates += track_config->max_bitrate_bps;
if (track_config->track_id == audio_track_id_) { if (track_config->track_id == audio_track_id_) {
audio_track_config = track_config; audio_track_config = track_config;
audio_config_index = &track_config - &track_configs[0]; audio_config_index = &track_config - &track_configs[0];
} }
} }
if (sum_max_bitrates < available_bitrate) {
// Allow non audio streams to go above max upto
// kTransmissionMaxBitrateMultiplier * max_bitrate_bps
size_t track_configs_size = track_configs.size();
std::vector<TrackConfig> increased_track_configs(track_configs_size);
std::vector<const TrackConfig*> increased_track_configs_ptr(
track_configs_size);
for (unsigned long i = 0; i < track_configs_size; i++) {
increased_track_configs[i] = (*track_configs[i]);
increased_track_configs_ptr[i] = &increased_track_configs[i];
if (track_configs[i]->track_id != audio_track_id_) {
increased_track_configs[i].max_bitrate_bps =
track_configs[i]->max_bitrate_bps *
kTransmissionMaxBitrateMultiplier;
}
}
return DistributeBitratesEvenly(increased_track_configs_ptr,
available_bitrate);
}
if (audio_track_config == nullptr) { if (audio_track_config == nullptr) {
return DistributeBitratesEvenly(track_configs, available_bitrate); return DistributeBitratesEvenly(track_configs, available_bitrate);
} }