admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Media track ID visibility at BWE level

Browse Source 
Track IDs are assigned by application during track creation. 
Track IDs are used by custom bitrate allocation strategies to identify tracks. 
Track ID can be empty, in that case bitrate allocation strategies will not be able to handle
these tracks specifically and will handle them as a default.

Bug: webrtc:8243
Change-Id: I89987e33328320bfd0539ad532342df6da144c98
Reviewed-on: https://webrtc-review.googlesource.com/4820
Commit-Queue: Alex Narest <alexnarest@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20285}
This commit is contained in:
Alex Narest 2017-10-13 14:56:18 +02:00 committed by Commit Bot
parent 385b10bbaa
commit b3944f021d
10 changed files with 60 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
audio/audio_send_stream.cc
View File

@ -627,7 +627,7 @@ void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
config_.min_bitrate_bps = min_bitrate_bps; config_.min_bitrate_bps = min_bitrate_bps;
config_.max_bitrate_bps = max_bitrate_bps; config_.max_bitrate_bps = max_bitrate_bps;
bitrate_allocator_->AddObserver(this, min_bitrate_bps, max_bitrate_bps, 0, bitrate_allocator_->AddObserver(this, min_bitrate_bps, max_bitrate_bps, 0,
true); true, config_.track_id);
thread_sync_event.Set(); thread_sync_event.Set();
}); });
thread_sync_event.Wait(rtc::Event::kForever); thread_sync_event.Wait(rtc::Event::kForever);

3
call/audio_send_stream.h
View File

@ -131,6 +131,9 @@ class AudioSendStream {
rtc::Optional<SendCodecSpec> send_codec_spec; rtc::Optional<SendCodecSpec> send_codec_spec;
rtc::scoped_refptr<AudioEncoderFactory> encoder_factory; rtc::scoped_refptr<AudioEncoderFactory> encoder_factory;
// Track ID as specified during track creation.
std::string track_id;
}; };
virtual ~AudioSendStream() = default; virtual ~AudioSendStream() = default;

5
call/bitrate_allocator.cc
View File

@ -124,7 +124,8 @@ void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer,
uint32_t min_bitrate_bps, uint32_t min_bitrate_bps,
uint32_t max_bitrate_bps, uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps, uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate) { bool enforce_min_bitrate,
std::string track_id) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
auto it = FindObserverConfig(observer); auto it = FindObserverConfig(observer);
@ -137,7 +138,7 @@ void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer,
} else { } else {
bitrate_observer_configs_.push_back( bitrate_observer_configs_.push_back(
ObserverConfig(observer, min_bitrate_bps, max_bitrate_bps, ObserverConfig(observer, min_bitrate_bps, max_bitrate_bps,
pad_up_bitrate_bps, enforce_min_bitrate)); pad_up_bitrate_bps, enforce_min_bitrate, track_id));
} }
ObserverAllocation allocation; ObserverAllocation allocation;

11
call/bitrate_allocator.h
View File

@ -14,6 +14,7 @@
#include <stdint.h> #include <stdint.h>
#include <map> #include <map>
#include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
@ -82,7 +83,8 @@ class BitrateAllocator {
uint32_t min_bitrate_bps, uint32_t min_bitrate_bps,
uint32_t max_bitrate_bps, uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps, uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate); bool enforce_min_bitrate,
std::string track_id);
// Removes a previously added observer, but will not trigger a new bitrate // Removes a previously added observer, but will not trigger a new bitrate
// allocation. // allocation.
@ -99,14 +101,16 @@ class BitrateAllocator {
uint32_t min_bitrate_bps, uint32_t min_bitrate_bps,
uint32_t max_bitrate_bps, uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps, uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate) bool enforce_min_bitrate,
std::string track_id)
: observer(observer), : observer(observer),
min_bitrate_bps(min_bitrate_bps), min_bitrate_bps(min_bitrate_bps),
max_bitrate_bps(max_bitrate_bps), max_bitrate_bps(max_bitrate_bps),
pad_up_bitrate_bps(pad_up_bitrate_bps), pad_up_bitrate_bps(pad_up_bitrate_bps),
enforce_min_bitrate(enforce_min_bitrate), enforce_min_bitrate(enforce_min_bitrate),
allocated_bitrate_bps(-1), allocated_bitrate_bps(-1),
media_ratio(1.0) {} media_ratio(1.0),
track_id(track_id) {}
BitrateAllocatorObserver* observer; BitrateAllocatorObserver* observer;
uint32_t min_bitrate_bps; uint32_t min_bitrate_bps;
@ -115,6 +119,7 @@ class BitrateAllocator {
bool enforce_min_bitrate; bool enforce_min_bitrate;
int64_t allocated_bitrate_bps; int64_t allocated_bitrate_bps;
double media_ratio; // Part of the total bitrate used for media [0.0, 1.0]. double media_ratio; // Part of the total bitrate used for media [0.0, 1.0].
std::string track_id;
}; };
// Calculates the minimum requested send bitrate and max padding bitrate and // Calculates the minimum requested send bitrate and max padding bitrate and

47
call/bitrate_allocator_unittest.cc
View File

@ -81,7 +81,7 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps,
kPadUpToBitrateBps)); kPadUpToBitrateBps));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000,
kPadUpToBitrateBps, true); kPadUpToBitrateBps, true, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs); allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
@ -95,11 +95,11 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
EXPECT_CALL(limit_observer_, EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(kMinSendBitrateBps, 0)); OnAllocationLimitsChanged(kMinSendBitrateBps, 0));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0,
true); true, "");
EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0, allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0,
true); true, "");
EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(1500000, 0, 0, kDefaultProbingIntervalMs); allocator_->OnNetworkChanged(1500000, 0, 0, kDefaultProbingIntervalMs);
@ -110,11 +110,11 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
TestBitrateObserver bitrate_observer_1; TestBitrateObserver bitrate_observer_1;
TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_2;
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(100000, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(100000, 0));
allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true); allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
EXPECT_CALL(limit_observer_, EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(100000 + 200000, 0)); OnAllocationLimitsChanged(100000 + 200000, 0));
allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true); allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true, "");
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
// Test too low start bitrate, hence lower than sum of min. Min bitrates // Test too low start bitrate, hence lower than sum of min. Min bitrates
@ -158,7 +158,7 @@ TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps,
kPadUpToBitrateBps)); kPadUpToBitrateBps));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000,
kPadUpToBitrateBps, true); kPadUpToBitrateBps, true, "");
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
allocator_->RemoveObserver(&bitrate_observer); allocator_->RemoveObserver(&bitrate_observer);
} }
@ -182,7 +182,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
// Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
// AddObserver is called with |enforce_min_bitrate| = false. // AddObserver is called with |enforce_min_bitrate| = false.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000));
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
// High BWE. // High BWE.
@ -202,14 +202,14 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_2;
TestBitrateObserver bitrate_observer_3; TestBitrateObserver bitrate_observer_3;
// Set up the observers with min bitrates at 100000, 200000, and 300000. // Set up the observers with min bitrates at 100000, 200000, and 300000.
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false); allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "");
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false); allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "");
EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3)); EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
@ -263,8 +263,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
// Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
// AddObserver is called with |enforce_min_bitrate| = false. // AddObserver is called with |enforce_min_bitrate| = false.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000));
allocator_->AddObserver( allocator_->AddObserver(&bitrate_observer, 100000, 400000, 0, false, "");
&bitrate_observer, 100000, 400000, 0, false);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
// High BWE. // High BWE.
@ -310,9 +309,9 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
TestBitrateObserver bitrate_observer_1; TestBitrateObserver bitrate_observer_1;
TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_2;
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false); allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "");
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
@ -361,14 +360,14 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_2;
TestBitrateObserver bitrate_observer_3; TestBitrateObserver bitrate_observer_3;
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true); allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true); allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, "");
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true); allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3));
EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_)); EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_));
EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_)); EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_));
@ -389,7 +388,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_1; TestBitrateObserver bitrate_observer_1;
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0));
allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true); allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
// Set network down, ie, no available bitrate. // Set network down, ie, no available bitrate.
@ -400,7 +399,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_2;
// Adding an observer while the network is down should not affect the limits. // Adding an observer while the network is down should not affect the limits.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0));
allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true); allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "");
// Expect the start_bitrate to be set as if the network was still up but that // Expect the start_bitrate to be set as if the network was still up but that
// the new observer have been notified that the network is down. // the new observer have been notified that the network is down.
@ -416,11 +415,11 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
TestBitrateObserver enforced_observer; TestBitrateObserver enforced_observer;
allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true); allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true, "");
EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer)); EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer));
TestBitrateObserver not_enforced_observer; TestBitrateObserver not_enforced_observer;
allocator_->AddObserver(&not_enforced_observer, 30000, 2500000, 0, false); allocator_->AddObserver(&not_enforced_observer, 30000, 2500000, 0, false, "");
EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer)); EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
@ -458,7 +457,7 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
TestBitrateObserver observer; TestBitrateObserver observer;
allocator_->AddObserver(&observer, 30000, 300000, 0, false); allocator_->AddObserver(&observer, 30000, 300000, 0, false, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
@ -484,7 +483,7 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
TestBitrateObserver observer; TestBitrateObserver observer;
allocator_->AddObserver(&observer, 300000, 600000, 0, false); allocator_->AddObserver(&observer, 300000, 600000, 0, false, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
@ -510,7 +509,7 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
TEST_F(BitrateAllocatorTest, PassProbingInterval) { TEST_F(BitrateAllocatorTest, PassProbingInterval) {
TestBitrateObserver observer; TestBitrateObserver observer;
allocator_->AddObserver(&observer, 300000, 600000, 0, false); allocator_->AddObserver(&observer, 300000, 600000, 0, false, "");
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(300000, 0, 50, 5000); allocator_->OnNetworkChanged(300000, 0, 50, 5000);

3
call/video_send_stream.h
View File

@ -220,6 +220,9 @@ class VideoSendStream {
// Enables periodic bandwidth probing in application-limited region. // Enables periodic bandwidth probing in application-limited region.
bool periodic_alr_bandwidth_probing = false; bool periodic_alr_bandwidth_probing = false;
// Track ID as specified during track creation.
std::string track_id;
private: private:
// Access to the copy constructor is private to force use of the Copy() // Access to the copy constructor is private to force use of the Copy()
// method for those exceptional cases where we do use it. // method for those exceptional cases where we do use it.

30
examples/objc/AppRTCMobile/ARDAppClient.m
View File

@ -538,8 +538,7 @@ static int const kKbpsMultiplier = 1000;
constraints:constraints constraints:constraints
delegate:self]; delegate:self];
// Create AV senders. // Create AV senders.
[self createAudioSender]; [self createMediaSenders];
[self createVideoSender];
if (_isInitiator) { if (_isInitiator) {
// Send offer. // Send offer.
__weak ARDAppClient *weakSelf = self; __weak ARDAppClient *weakSelf = self;
@ -663,19 +662,6 @@ static int const kKbpsMultiplier = 1000;
} }
} }
- (RTCRtpSender *)createVideoSender {
RTCRtpSender *sender =
[_peerConnection senderWithKind:kRTCMediaStreamTrackKindVideo
streamId:kARDMediaStreamId];
_localVideoTrack = [self createLocalVideoTrack];
if (_localVideoTrack) {
sender.track = _localVideoTrack;
[_delegate appClient:self didReceiveLocalVideoTrack:_localVideoTrack];
}
return sender;
}
- (void)setMaxBitrateForPeerConnectionVideoSender { - (void)setMaxBitrateForPeerConnectionVideoSender {
for (RTCRtpSender *sender in _peerConnection.senders) { for (RTCRtpSender *sender in _peerConnection.senders) {
if (sender.track != nil) { if (sender.track != nil) {
@ -698,16 +684,18 @@ static int const kKbpsMultiplier = 1000;
[sender setParameters:parametersToModify]; [sender setParameters:parametersToModify];
} }
- (RTCRtpSender *)createAudioSender { - (void)createMediaSenders {
RTCMediaConstraints *constraints = [self defaultMediaAudioConstraints]; RTCMediaConstraints *constraints = [self defaultMediaAudioConstraints];
RTCAudioSource *source = [_factory audioSourceWithConstraints:constraints]; RTCAudioSource *source = [_factory audioSourceWithConstraints:constraints];
RTCAudioTrack *track = [_factory audioTrackWithSource:source RTCAudioTrack *track = [_factory audioTrackWithSource:source
trackId:kARDAudioTrackId]; trackId:kARDAudioTrackId];
RTCRtpSender *sender = RTCMediaStream *stream = [_factory mediaStreamWithStreamId:kARDMediaStreamId];
[_peerConnection senderWithKind:kRTCMediaStreamTrackKindAudio [stream addAudioTrack:track];
streamId:kARDMediaStreamId]; _localVideoTrack = [self createLocalVideoTrack];
sender.track = track; if (_localVideoTrack) {
return sender; [stream addVideoTrack:_localVideoTrack];
}
[_peerConnection addStream:stream];
} }
- (RTCVideoTrack *)createLocalVideoTrack { - (RTCVideoTrack *)createLocalVideoTrack {

1
media/engine/webrtcvideoengine.cc
View File

@ -1597,6 +1597,7 @@ WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
} }
parameters_.config.rtp.c_name = sp.cname; parameters_.config.rtp.c_name = sp.cname;
parameters_.config.track_id = sp.id;
if (rtp_extensions) { if (rtp_extensions) {
parameters_.config.rtp.extensions = *rtp_extensions; parameters_.config.rtp.extensions = *rtp_extensions;
} }

4
media/engine/webrtcvoiceengine.cc
View File

@ -809,6 +809,7 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
webrtc::AudioTransport* voe_audio_transport, webrtc::AudioTransport* voe_audio_transport,
uint32_t ssrc, uint32_t ssrc,
const std::string& c_name, const std::string& c_name,
const std::string track_id,
const rtc::Optional<webrtc::AudioSendStream::Config::SendCodecSpec>& const rtc::Optional<webrtc::AudioSendStream::Config::SendCodecSpec>&
send_codec_spec, send_codec_spec,
const std::vector<webrtc::RtpExtension>& extensions, const std::vector<webrtc::RtpExtension>& extensions,
@ -835,6 +836,7 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
config_.rtp.extensions = extensions; config_.rtp.extensions = extensions;
config_.audio_network_adaptor_config = audio_network_adaptor_config; config_.audio_network_adaptor_config = audio_network_adaptor_config;
config_.encoder_factory = encoder_factory; config_.encoder_factory = encoder_factory;
config_.track_id = track_id;
rtp_parameters_.encodings[0].ssrc = rtc::Optional<uint32_t>(ssrc); rtp_parameters_.encodings[0].ssrc = rtc::Optional<uint32_t>(ssrc);
if (send_codec_spec) { if (send_codec_spec) {
@ -1836,7 +1838,7 @@ bool WebRtcVoiceMediaChannel::AddSendStream(const StreamParams& sp) {
rtc::Optional<std::string> audio_network_adaptor_config = rtc::Optional<std::string> audio_network_adaptor_config =
GetAudioNetworkAdaptorConfig(options_); GetAudioNetworkAdaptorConfig(options_);
WebRtcAudioSendStream* stream = new WebRtcAudioSendStream( WebRtcAudioSendStream* stream = new WebRtcAudioSendStream(
channel, audio_transport, ssrc, sp.cname, send_codec_spec_, channel, audio_transport, ssrc, sp.cname, sp.id, send_codec_spec_,
send_rtp_extensions_, max_send_bitrate_bps_, audio_network_adaptor_config, send_rtp_extensions_, max_send_bitrate_bps_, audio_network_adaptor_config,
call_, this, engine()->encoder_factory_); call_, this, engine()->encoder_factory_);
send_streams_.insert(std::make_pair(ssrc, stream)); send_streams_.insert(std::make_pair(ssrc, stream));

9
video/video_send_stream.cc
View File

@ -842,7 +842,8 @@ void VideoSendStreamImpl::Start() {
bitrate_allocator_->AddObserver( bitrate_allocator_->AddObserver(
this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_, this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
max_padding_bitrate_, !config_->suspend_below_min_bitrate); max_padding_bitrate_, !config_->suspend_below_min_bitrate,
config_->track_id);
// Start monitoring encoder activity. // Start monitoring encoder activity.
{ {
@ -895,7 +896,8 @@ void VideoSendStreamImpl::SignalEncoderActive() {
LOG(LS_INFO) << "SignalEncoderActive, Encoder is active."; LOG(LS_INFO) << "SignalEncoderActive, Encoder is active.";
bitrate_allocator_->AddObserver( bitrate_allocator_->AddObserver(
this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_, this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
max_padding_bitrate_, !config_->suspend_below_min_bitrate); max_padding_bitrate_, !config_->suspend_below_min_bitrate,
config_->track_id);
} }
void VideoSendStreamImpl::OnEncoderConfigurationChanged( void VideoSendStreamImpl::OnEncoderConfigurationChanged(
@ -937,7 +939,8 @@ void VideoSendStreamImpl::OnEncoderConfigurationChanged(
// limits. // limits.
bitrate_allocator_->AddObserver( bitrate_allocator_->AddObserver(
this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_, this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
max_padding_bitrate_, !config_->suspend_below_min_bitrate); max_padding_bitrate_, !config_->suspend_below_min_bitrate,
config_->track_id);
} }
} }