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

Support for two audio codec lists down into WebRtcVoiceEngine.

Browse Source 
Added the plumbing necessary to get two different lists of codecs from
WebRtcVoiceEngine up to MediaSessionDescriptionFactory.

This should be the last step in this set of CLs. Once
https://codereview.webrtc.org/1991233004/ has landed, it's possible to
implement the ReceiveCodecs getter with the info from the
AudioDecoderFactory. The factory needs to be updated to actually
produce the correct list, as well.

BUG=webrtc:5805

Review-Url: https://codereview.webrtc.org/2013053002
Cr-Commit-Position: refs/heads/master@{#13131}
This commit is contained in:
ossu 2016-06-14 07:12:39 -07:00 committed by Commit bot
parent 79ede033f6
commit dedfd28a52
11 changed files with 57 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
webrtc/api/webrtcsession_unittest.cc
View File

@ -1336,7 +1336,8 @@ class WebRtcSessionTest
const cricket::AudioCodec kCNCodec2(103, "CN", 16000, 0, 1);
// Add kCNCodec for dtmf test.
std::vector<cricket::AudioCodec> codecs = media_engine_->audio_codecs();;
std::vector<cricket::AudioCodec> codecs =
media_engine_->audio_send_codecs();
codecs.push_back(kCNCodec1);
codecs.push_back(kCNCodec2);
media_engine_->SetAudioCodecs(codecs);

7
webrtc/media/base/fakemediaengine.h
View File

@ -767,8 +767,11 @@ class FakeVoiceEngine : public FakeBaseEngine {
channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
}
const std::vector<AudioCodec>& codecs() { return codecs_; }
void SetCodecs(const std::vector<AudioCodec> codecs) { codecs_ = codecs; }
// TODO(ossu): For proper testing, These should either individually settable
// or the voice engine should reference mockable factories.
const std::vector<AudioCodec>& send_codecs() { return codecs_; }
const std::vector<AudioCodec>& recv_codecs() { return codecs_; }
void SetCodecs(const std::vector<AudioCodec>& codecs) { codecs_ = codecs; }
bool GetOutputVolume(int* level) {
*level = output_volume_;

10
webrtc/media/base/mediaengine.h
View File

@ -81,7 +81,8 @@ class MediaEngineInterface {
// Gets the current microphone level, as a value between 0 and 10.
virtual int GetInputLevel() = 0;
virtual const std::vector<AudioCodec>& audio_codecs() = 0;
virtual const std::vector<AudioCodec>& audio_send_codecs() = 0;
virtual const std::vector<AudioCodec>& audio_recv_codecs() = 0;
virtual RtpCapabilities GetAudioCapabilities() = 0;
virtual const std::vector<VideoCodec>& video_codecs() = 0;
virtual RtpCapabilities GetVideoCapabilities() = 0;
@ -163,8 +164,11 @@ class CompositeMediaEngine : public MediaEngineInterface {
virtual int GetInputLevel() {
return voice_.GetInputLevel();
}
virtual const std::vector<AudioCodec>& audio_codecs() {
return voice_.codecs();
virtual const std::vector<AudioCodec>& audio_send_codecs() {
return voice_.send_codecs();
}
virtual const std::vector<AudioCodec>& audio_recv_codecs() {
return voice_.recv_codecs();
}
virtual RtpCapabilities GetAudioCapabilities() {
return voice_.GetCapabilities();

7
webrtc/media/engine/webrtcvoiceengine.cc
View File

@ -948,7 +948,12 @@ int WebRtcVoiceEngine::GetInputLevel() {
static_cast<int>(ulevel) : -1;
}
const std::vector<AudioCodec>& WebRtcVoiceEngine::codecs() {
const std::vector<AudioCodec>& WebRtcVoiceEngine::send_codecs() const {
RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
return codecs_;
}
const std::vector<AudioCodec>& WebRtcVoiceEngine::recv_codecs() const {
RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
return codecs_;
}

3
webrtc/media/engine/webrtcvoiceengine.h
View File

@ -65,7 +65,8 @@ class WebRtcVoiceEngine final : public webrtc::TraceCallback {
bool SetOutputVolume(int level);
int GetInputLevel();
const std::vector<AudioCodec>& codecs();
const std::vector<AudioCodec>& send_codecs() const;
const std::vector<AudioCodec>& recv_codecs() const;
RtpCapabilities GetCapabilities() const;
// For tracking WebRtc channels. Needed because we have to pause them

16
webrtc/media/engine/webrtcvoiceengine_unittest.cc
View File

@ -525,8 +525,10 @@ TEST_F(WebRtcVoiceEngineTestFake, CreateRecvStream) {
// Tests that the list of supported codecs is created properly and ordered
// correctly (such that opus appears first).
// TODO(ossu): This test should move into a separate builtin audio codecs
// module.
TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) {
const std::vector<cricket::AudioCodec>& codecs = engine_->codecs();
const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
ASSERT_FALSE(codecs.empty());
EXPECT_STRCASEEQ("opus", codecs[0].name.c_str());
EXPECT_EQ(48000, codecs[0].clockrate);
@ -535,7 +537,7 @@ TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) {
}
TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
const std::vector<cricket::AudioCodec>& codecs = engine_->codecs();
const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
bool opus_found = false;
for (cricket::AudioCodec codec : codecs) {
if (codec.name == "opus") {
@ -831,7 +833,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
EXPECT_TRUE(SetupChannel());
const int kDesiredBitrate = 128000;
cricket::AudioSendParameters parameters;
parameters.codecs = engine_->codecs();
parameters.codecs = engine_->send_codecs();
parameters.max_bandwidth_bps = kDesiredBitrate;
EXPECT_TRUE(channel_->SetSendParameters(parameters));
@ -1579,7 +1581,7 @@ TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
EXPECT_FALSE(
call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
send_parameters.codecs = engine_->codecs();
send_parameters.codecs = engine_->send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
EXPECT_TRUE(
@ -3576,6 +3578,8 @@ TEST(WebRtcVoiceEngineTest, StartupShutdownWithExternalADM) {
}
// Tests that the library is configured with the codecs we want.
// TODO(ossu): This test should move into the builtin audio codecs module
// eventually.
TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
// TODO(ossu): These tests should move into a future "builtin audio codecs"
// module.
@ -3636,7 +3640,7 @@ TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
cricket::WebRtcVoiceEngine engine(nullptr,
webrtc::CreateBuiltinAudioDecoderFactory());
for (std::vector<cricket::AudioCodec>::const_iterator it =
engine.codecs().begin(); it != engine.codecs().end(); ++it) {
engine.send_codecs().begin(); it != engine.send_codecs().end(); ++it) {
if (it->name == "CN" && it->clockrate == 16000) {
EXPECT_EQ(105, it->id);
} else if (it->name == "CN" && it->clockrate == 32000) {
@ -3701,6 +3705,6 @@ TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(),
cricket::AudioOptions(), call.get());
cricket::AudioRecvParameters parameters;
parameters.codecs = engine.codecs();
parameters.codecs = engine.recv_codecs();
EXPECT_TRUE(channel.SetRecvParameters(parameters));
}

13
webrtc/pc/channelmanager.cc
View File

@ -100,15 +100,14 @@ bool ChannelManager::SetVideoRtxEnabled(bool enable) {
}
}
void ChannelManager::GetSupportedAudioCodecs(
void ChannelManager::GetSupportedAudioSendCodecs(
std::vector<AudioCodec>* codecs) const {
codecs->clear();
*codecs = media_engine_->audio_send_codecs();
}
for (std::vector<AudioCodec>::const_iterator it =
media_engine_->audio_codecs().begin();
it != media_engine_->audio_codecs().end(); ++it) {
codecs->push_back(*it);
}
void ChannelManager::GetSupportedAudioReceiveCodecs(
std::vector<AudioCodec>* codecs) const {
*codecs = media_engine_->audio_recv_codecs();
}
void ChannelManager::GetSupportedAudioRtpHeaderExtensions(

3
webrtc/pc/channelmanager.h
View File

@ -72,7 +72,8 @@ class ChannelManager {
// Retrieves the list of supported audio & video codec types.
// Can be called before starting the media engine.
void GetSupportedAudioCodecs(std::vector<AudioCodec>* codecs) const;
void GetSupportedAudioSendCodecs(std::vector<AudioCodec>* codecs) const;
void GetSupportedAudioReceiveCodecs(std::vector<AudioCodec>* codecs) const;
void GetSupportedAudioRtpHeaderExtensions(RtpHeaderExtensions* ext) const;
void GetSupportedVideoCodecs(std::vector<VideoCodec>* codecs) const;
void GetSupportedVideoRtpHeaderExtensions(RtpHeaderExtensions* ext) const;

11
webrtc/pc/mediasession.cc
View File

@ -1273,16 +1273,19 @@ MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
: secure_(SEC_DISABLED),
add_legacy_(true),
transport_desc_factory_(transport_desc_factory) {
channel_manager->GetSupportedAudioCodecs(&audio_sendrecv_codecs_);
channel_manager->GetSupportedAudioSendCodecs(&audio_send_codecs_);
channel_manager->GetSupportedAudioReceiveCodecs(&audio_recv_codecs_);
channel_manager->GetSupportedAudioSendCodecs(&audio_send_codecs_);
channel_manager->GetSupportedAudioRtpHeaderExtensions(&audio_rtp_extensions_);
channel_manager->GetSupportedVideoCodecs(&video_codecs_);
channel_manager->GetSupportedVideoRtpHeaderExtensions(&video_rtp_extensions_);
channel_manager->GetSupportedDataCodecs(&data_codecs_);
audio_send_codecs_ = audio_sendrecv_codecs_;
audio_recv_codecs_ = audio_sendrecv_codecs_;
NegotiateCodecs(audio_recv_codecs_, audio_send_codecs_,
&audio_sendrecv_codecs_);
}
const AudioCodecs& MediaSessionDescriptionFactory::audio_codecs() const {
const AudioCodecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs()
const {
return audio_sendrecv_codecs_;
}

2
webrtc/pc/mediasession.h
View File

@ -428,7 +428,7 @@ class MediaSessionDescriptionFactory {
MediaSessionDescriptionFactory(ChannelManager* cmanager,
const TransportDescriptionFactory* factory);
const AudioCodecs& audio_codecs() const;
const AudioCodecs& audio_sendrecv_codecs() const;
const AudioCodecs& audio_send_codecs() const;
const AudioCodecs& audio_recv_codecs() const;
void set_audio_codecs(const AudioCodecs& send_codecs,

18
webrtc/pc/mediasession_unittest.cc
View File

@ -474,7 +474,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOffer) {
const AudioContentDescription* acd =
static_cast<const AudioContentDescription*>(ac->description);
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
@ -500,7 +500,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
const VideoContentDescription* vcd =
static_cast<const VideoContentDescription*>(vc->description);
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
@ -520,7 +520,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
// duplicate RTP payload types.
TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
const VideoCodec& offered_video_codec = f2_.video_codecs()[0];
const AudioCodec& offered_audio_codec = f2_.audio_codecs()[0];
const AudioCodec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
const DataCodec& offered_data_codec = f2_.data_codecs()[0];
ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
ASSERT_EQ(offered_video_codec.id, offered_data_codec.id);
@ -607,7 +607,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateRtpDataOffer) {
const DataContentDescription* dcd =
static_cast<const DataContentDescription*>(dc->description);
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
EXPECT_NE(0U, acd->first_ssrc()); // a random nonzero ssrc
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
@ -1222,7 +1222,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
const DataContentDescription* dcd =
static_cast<const DataContentDescription*>(dc->description);
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(f1_.audio_codecs(), acd->codecs());
EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs());
const StreamParamsVec& audio_streams = acd->streams();
ASSERT_EQ(2U, audio_streams.size());
@ -2486,25 +2486,25 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestSetAudioCodecs) {
sf.set_audio_codecs(send_codecs, recv_codecs);
EXPECT_TRUE(sf.audio_send_codecs() == send_codecs);
EXPECT_TRUE(sf.audio_recv_codecs() == recv_codecs);
EXPECT_TRUE(sf.audio_codecs() == sendrecv_codecs);
EXPECT_TRUE(sf.audio_sendrecv_codecs() == sendrecv_codecs);
// Test empty send codecs list
sf.set_audio_codecs(no_codecs, recv_codecs);
EXPECT_TRUE(sf.audio_send_codecs() == no_codecs);
EXPECT_TRUE(sf.audio_recv_codecs() == recv_codecs);
EXPECT_TRUE(sf.audio_codecs() == no_codecs);
EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
// Test empty recv codecs list
sf.set_audio_codecs(send_codecs, no_codecs);
EXPECT_TRUE(sf.audio_send_codecs() == send_codecs);
EXPECT_TRUE(sf.audio_recv_codecs() == no_codecs);
EXPECT_TRUE(sf.audio_codecs() == no_codecs);
EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
// Test all empty codec lists
sf.set_audio_codecs(no_codecs, no_codecs);
EXPECT_TRUE(sf.audio_send_codecs() == no_codecs);
EXPECT_TRUE(sf.audio_recv_codecs() == no_codecs);
EXPECT_TRUE(sf.audio_codecs() == no_codecs);
EXPECT_TRUE(sf.audio_sendrecv_codecs() == no_codecs);
}
namespace {