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

Enable SSRC 0 in MediaChannel methods

Browse Source 
Refactor voice engine and video engine to use default methods instead of
treating 0 as a special value.

Bug: webrtc:8694
Change-Id: I47c211c6e870cdec737d6b0d05df29a9b534a011
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/158600
Reviewed-by: Markus Handell <handellm@webrtc.org>
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Commit-Queue: Saurav Das <dinosaurav@chromium.org>
Cr-Commit-Position: refs/heads/master@{#30010}
This commit is contained in:
Saurav Das 2019-12-04 09:31:36 -08:00 committed by Commit Bot
parent 503d7237ce
commit 749f6604a1
13 changed files with 206 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
media/base/fake_media_engine.cc
View File

@ -147,18 +147,18 @@ bool FakeVoiceMediaChannel::InsertDtmf(uint32_t ssrc,
return true; return true;
} }
bool FakeVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) { bool FakeVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) {
if (0 == ssrc) { if (output_scalings_.find(ssrc) != output_scalings_.end()) {
std::map<uint32_t, double>::iterator it;
for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) {
it->second = volume;
}
return true;
} else if (output_scalings_.find(ssrc) != output_scalings_.end()) {
output_scalings_[ssrc] = volume; output_scalings_[ssrc] = volume;
return true; return true;
} }
return false; return false;
} }
bool FakeVoiceMediaChannel::SetDefaultOutputVolume(double volume) {
for (auto& entry : output_scalings_) {
entry.second = volume;
}
return true;
}
bool FakeVoiceMediaChannel::GetOutputVolume(uint32_t ssrc, double* volume) { bool FakeVoiceMediaChannel::GetOutputVolume(uint32_t ssrc, double* volume) {
if (output_scalings_.find(ssrc) == output_scalings_.end()) if (output_scalings_.find(ssrc) == output_scalings_.end())
return false; return false;
@ -190,6 +190,10 @@ void FakeVoiceMediaChannel::SetRawAudioSink(
std::unique_ptr<webrtc::AudioSinkInterface> sink) { std::unique_ptr<webrtc::AudioSinkInterface> sink) {
sink_ = std::move(sink); sink_ = std::move(sink);
} }
void FakeVoiceMediaChannel::SetDefaultRawAudioSink(
std::unique_ptr<webrtc::AudioSinkInterface> sink) {
sink_ = std::move(sink);
}
std::vector<webrtc::RtpSource> FakeVoiceMediaChannel::GetSources( std::vector<webrtc::RtpSource> FakeVoiceMediaChannel::GetSources(
uint32_t ssrc) const { uint32_t ssrc) const {
return std::vector<webrtc::RtpSource>(); return std::vector<webrtc::RtpSource>();
@ -308,14 +312,15 @@ bool FakeVideoMediaChannel::GetSendCodec(VideoCodec* send_codec) {
bool FakeVideoMediaChannel::SetSink( bool FakeVideoMediaChannel::SetSink(
uint32_t ssrc, uint32_t ssrc,
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
if (ssrc != 0 && sinks_.find(ssrc) == sinks_.end()) { auto it = sinks_.find(ssrc);
if (it == sinks_.end()) {
return false; return false;
} }
if (ssrc != 0) { it->second = sink;
sinks_[ssrc] = sink;
}
return true; return true;
} }
void FakeVideoMediaChannel::SetDefaultSink(
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {}
bool FakeVideoMediaChannel::HasSink(uint32_t ssrc) const { bool FakeVideoMediaChannel::HasSink(uint32_t ssrc) const {
return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr; return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr;
} }

9
media/base/fake_media_engine.h
View File

@ -168,6 +168,9 @@ class RtpHelper : public Base {
} }
return webrtc::RtpParameters(); return webrtc::RtpParameters();
} }
virtual webrtc::RtpParameters GetDefaultRtpReceiveParameters() const {
return webrtc::RtpParameters();
}
bool IsStreamMuted(uint32_t ssrc) const { bool IsStreamMuted(uint32_t ssrc) const {
bool ret = muted_streams_.find(ssrc) != muted_streams_.end(); bool ret = muted_streams_.find(ssrc) != muted_streams_.end();
@ -338,6 +341,8 @@ class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override; bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override;
bool SetOutputVolume(uint32_t ssrc, double volume) override; bool SetOutputVolume(uint32_t ssrc, double volume) override;
bool SetDefaultOutputVolume(double volume) override;
bool GetOutputVolume(uint32_t ssrc, double* volume); bool GetOutputVolume(uint32_t ssrc, double* volume);
bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override; bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override;
@ -349,6 +354,8 @@ class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
void SetRawAudioSink( void SetRawAudioSink(
uint32_t ssrc, uint32_t ssrc,
std::unique_ptr<webrtc::AudioSinkInterface> sink) override; std::unique_ptr<webrtc::AudioSinkInterface> sink) override;
void SetDefaultRawAudioSink(
std::unique_ptr<webrtc::AudioSinkInterface> sink) override;
std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override; std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override;
@ -415,6 +422,8 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
bool GetSendCodec(VideoCodec* send_codec) override; bool GetSendCodec(VideoCodec* send_codec) override;
bool SetSink(uint32_t ssrc, bool SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override; rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
void SetDefaultSink(
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
bool HasSink(uint32_t ssrc) const; bool HasSink(uint32_t ssrc) const;
bool SetSend(bool send) override; bool SetSend(bool send) override;

22
media/base/media_channel.h
View File

@ -802,12 +802,11 @@ class VoiceMediaChannel : public MediaChannel, public Delayable {
virtual bool SetSendParameters(const AudioSendParameters& params) = 0; virtual bool SetSendParameters(const AudioSendParameters& params) = 0;
virtual bool SetRecvParameters(const AudioRecvParameters& params) = 0; virtual bool SetRecvParameters(const AudioRecvParameters& params) = 0;
// Get the receive parameters for the incoming stream identified by |ssrc|. // Get the receive parameters for the incoming stream identified by |ssrc|.
// If |ssrc| is 0, retrieve the receive parameters for the default receive
// stream, which is used when SSRCs are not signaled. Note that calling with
// an |ssrc| of 0 will return encoding parameters with an unset |ssrc|
// member.
virtual webrtc::RtpParameters GetRtpReceiveParameters( virtual webrtc::RtpParameters GetRtpReceiveParameters(
uint32_t ssrc) const = 0; uint32_t ssrc) const = 0;
// Retrieve the receive parameters for the default receive
// stream, which is used when SSRCs are not signaled.
virtual webrtc::RtpParameters GetDefaultRtpReceiveParameters() const = 0;
// Starts or stops playout of received audio. // Starts or stops playout of received audio.
virtual void SetPlayout(bool playout) = 0; virtual void SetPlayout(bool playout) = 0;
// Starts or stops sending (and potentially capture) of local audio. // Starts or stops sending (and potentially capture) of local audio.
@ -819,6 +818,8 @@ class VoiceMediaChannel : public MediaChannel, public Delayable {
AudioSource* source) = 0; AudioSource* source) = 0;
// Set speaker output volume of the specified ssrc. // Set speaker output volume of the specified ssrc.
virtual bool SetOutputVolume(uint32_t ssrc, double volume) = 0; virtual bool SetOutputVolume(uint32_t ssrc, double volume) = 0;
// Set speaker output volume for future unsignaled streams.
virtual bool SetDefaultOutputVolume(double volume) = 0;
// Returns if the telephone-event has been negotiated. // Returns if the telephone-event has been negotiated.
virtual bool CanInsertDtmf() = 0; virtual bool CanInsertDtmf() = 0;
// Send a DTMF |event|. The DTMF out-of-band signal will be used. // Send a DTMF |event|. The DTMF out-of-band signal will be used.
@ -832,6 +833,8 @@ class VoiceMediaChannel : public MediaChannel, public Delayable {
virtual void SetRawAudioSink( virtual void SetRawAudioSink(
uint32_t ssrc, uint32_t ssrc,
std::unique_ptr<webrtc::AudioSinkInterface> sink) = 0; std::unique_ptr<webrtc::AudioSinkInterface> sink) = 0;
virtual void SetDefaultRawAudioSink(
std::unique_ptr<webrtc::AudioSinkInterface> sink) = 0;
virtual std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const = 0; virtual std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const = 0;
}; };
@ -868,12 +871,11 @@ class VideoMediaChannel : public MediaChannel, public Delayable {
virtual bool SetSendParameters(const VideoSendParameters& params) = 0; virtual bool SetSendParameters(const VideoSendParameters& params) = 0;
virtual bool SetRecvParameters(const VideoRecvParameters& params) = 0; virtual bool SetRecvParameters(const VideoRecvParameters& params) = 0;
// Get the receive parameters for the incoming stream identified by |ssrc|. // Get the receive parameters for the incoming stream identified by |ssrc|.
// If |ssrc| is 0, retrieve the receive parameters for the default receive
// stream, which is used when SSRCs are not signaled. Note that calling with
// an |ssrc| of 0 will return encoding parameters with an unset |ssrc|
// member.
virtual webrtc::RtpParameters GetRtpReceiveParameters( virtual webrtc::RtpParameters GetRtpReceiveParameters(
uint32_t ssrc) const = 0; uint32_t ssrc) const = 0;
// Retrieve the receive parameters for the default receive
// stream, which is used when SSRCs are not signaled.
virtual webrtc::RtpParameters GetDefaultRtpReceiveParameters() const = 0;
// Gets the currently set codecs/payload types to be used for outgoing media. // Gets the currently set codecs/payload types to be used for outgoing media.
virtual bool GetSendCodec(VideoCodec* send_codec) = 0; virtual bool GetSendCodec(VideoCodec* send_codec) = 0;
// Starts or stops transmission (and potentially capture) of local video. // Starts or stops transmission (and potentially capture) of local video.
@ -885,9 +887,11 @@ class VideoMediaChannel : public MediaChannel, public Delayable {
const VideoOptions* options, const VideoOptions* options,
rtc::VideoSourceInterface<webrtc::VideoFrame>* source) = 0; rtc::VideoSourceInterface<webrtc::VideoFrame>* source) = 0;
// Sets the sink object to be used for the specified stream. // Sets the sink object to be used for the specified stream.
// If SSRC is 0, the sink is used for the 'default' stream.
virtual bool SetSink(uint32_t ssrc, virtual bool SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) = 0; rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) = 0;
// The sink is used for the 'default' stream.
virtual void SetDefaultSink(
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) = 0;
// This fills the "bitrate parts" (rtx, video bitrate) of the // This fills the "bitrate parts" (rtx, video bitrate) of the
// BandwidthEstimationInfo, since that part that isn't possible to get // BandwidthEstimationInfo, since that part that isn't possible to get
// through webrtc::Call::GetStats, as they are statistics of the send // through webrtc::Call::GetStats, as they are statistics of the send

57
media/engine/webrtc_video_engine.cc
View File

@ -923,26 +923,34 @@ webrtc::RtpParameters WebRtcVideoChannel::GetRtpReceiveParameters(
uint32_t ssrc) const { uint32_t ssrc) const {
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
webrtc::RtpParameters rtp_params; webrtc::RtpParameters rtp_params;
// SSRC of 0 represents an unsignaled receive stream. auto it = receive_streams_.find(ssrc);
if (ssrc == 0) { if (it == receive_streams_.end()) {
if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) { RTC_LOG(LS_WARNING)
RTC_LOG(LS_WARNING) << "Attempting to get RTP receive parameters for stream "
<< "Attempting to get RTP parameters for the default, " << "with SSRC " << ssrc << " which doesn't exist.";
"unsignaled video receive stream, but not yet " return webrtc::RtpParameters();
"configured to receive such a stream.";
return rtp_params;
}
rtp_params.encodings.emplace_back();
} else {
auto it = receive_streams_.find(ssrc);
if (it == receive_streams_.end()) {
RTC_LOG(LS_WARNING)
<< "Attempting to get RTP receive parameters for stream "
<< "with SSRC " << ssrc << " which doesn't exist.";
return webrtc::RtpParameters();
}
rtp_params = it->second->GetRtpParameters();
} }
rtp_params = it->second->GetRtpParameters();
// Add codecs, which any stream is prepared to receive.
for (const VideoCodec& codec : recv_params_.codecs) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
return rtp_params;
}
webrtc::RtpParameters WebRtcVideoChannel::GetDefaultRtpReceiveParameters()
const {
RTC_DCHECK_RUN_ON(&thread_checker_);
webrtc::RtpParameters rtp_params;
if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) {
RTC_LOG(LS_WARNING) << "Attempting to get RTP parameters for the default, "
"unsignaled video receive stream, but not yet "
"configured to receive such a stream.";
return rtp_params;
}
rtp_params.encodings.emplace_back();
// Add codecs, which any stream is prepared to receive. // Add codecs, which any stream is prepared to receive.
for (const VideoCodec& codec : recv_params_.codecs) { for (const VideoCodec& codec : recv_params_.codecs) {
@ -1360,10 +1368,6 @@ bool WebRtcVideoChannel::SetSink(
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " " RTC_LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " "
<< (sink ? "(ptr)" : "nullptr"); << (sink ? "(ptr)" : "nullptr");
if (ssrc == 0) {
default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink);
return true;
}
std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
receive_streams_.find(ssrc); receive_streams_.find(ssrc);
@ -1375,6 +1379,13 @@ bool WebRtcVideoChannel::SetSink(
return true; return true;
} }
void WebRtcVideoChannel::SetDefaultSink(
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_LOG(LS_INFO) << "SetDefaultSink: " << (sink ? "(ptr)" : "nullptr");
default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink);
}
bool WebRtcVideoChannel::GetStats(VideoMediaInfo* info) { bool WebRtcVideoChannel::GetStats(VideoMediaInfo* info) {
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
TRACE_EVENT0("webrtc", "WebRtcVideoChannel::GetStats"); TRACE_EVENT0("webrtc", "WebRtcVideoChannel::GetStats");

8
media/engine/webrtc_video_engine.h
View File

@ -129,6 +129,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
uint32_t ssrc, uint32_t ssrc,
const webrtc::RtpParameters& parameters) override; const webrtc::RtpParameters& parameters) override;
webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override; webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override;
webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override;
bool GetSendCodec(VideoCodec* send_codec) override; bool GetSendCodec(VideoCodec* send_codec) override;
bool SetSend(bool send) override; bool SetSend(bool send) override;
bool SetVideoSend( bool SetVideoSend(
@ -143,6 +144,8 @@ class WebRtcVideoChannel : public VideoMediaChannel,
void ResetUnsignaledRecvStream() override; void ResetUnsignaledRecvStream() override;
bool SetSink(uint32_t ssrc, bool SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override; rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
void SetDefaultSink(
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override; void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override;
bool GetStats(VideoMediaInfo* info) override; bool GetStats(VideoMediaInfo* info) override;
@ -210,6 +213,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
void RequestEncoderFallback() override; void RequestEncoderFallback() override;
void RequestEncoderSwitch( void RequestEncoderSwitch(
const EncoderSwitchRequestCallback::Config& conf) override; const EncoderSwitchRequestCallback::Config& conf) override;
void SetRecordableEncodedFrameCallback( void SetRecordableEncodedFrameCallback(
uint32_t ssrc, uint32_t ssrc,
std::function<void(const webrtc::RecordableEncodedFrame&)> callback) std::function<void(const webrtc::RecordableEncodedFrame&)> callback)
@ -220,8 +224,8 @@ class WebRtcVideoChannel : public VideoMediaChannel,
private: private:
class WebRtcVideoReceiveStream; class WebRtcVideoReceiveStream;
// Finds VideoReceiveStream corresponding to ssrc. Aware of unsignalled // Finds VideoReceiveStream corresponding to ssrc. Aware of unsignalled ssrc
// ssrc handling. // handling.
WebRtcVideoReceiveStream* FindReceiveStream(uint32_t ssrc) WebRtcVideoReceiveStream* FindReceiveStream(uint32_t ssrc)
RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_); RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_);

44
media/engine/webrtc_video_engine_unittest.cc
View File

@ -79,7 +79,6 @@ static const int kDefaultQpMax = 56;
static const uint8_t kRedRtxPayloadType = 125; static const uint8_t kRedRtxPayloadType = 125;
static const uint32_t kTimeout = 5000U; static const uint32_t kTimeout = 5000U;
static const uint32_t kDefaultReceiveSsrc = 0;
static const uint32_t kSsrc = 1234u; static const uint32_t kSsrc = 1234u;
static const uint32_t kSsrcs4[] = {1, 2, 3, 4}; static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
static const int kVideoWidth = 640; static const int kVideoWidth = 640;
@ -91,7 +90,6 @@ static const uint32_t kSsrcs3[] = {1, 2, 3};
static const uint32_t kRtxSsrcs1[] = {4}; static const uint32_t kRtxSsrcs1[] = {4};
static const uint32_t kFlexfecSsrc = 5; static const uint32_t kFlexfecSsrc = 5;
static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE; static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
static const uint32_t kDefaultRecvSsrc = 0;
constexpr uint32_t kRtpHeaderSize = 12; constexpr uint32_t kRtpHeaderSize = 12;
@ -1579,7 +1577,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
void SendAndReceive(const cricket::VideoCodec& codec) { void SendAndReceive(const cricket::VideoCodec& codec) {
EXPECT_TRUE(SetOneCodec(codec)); EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); channel_->SetDefaultSink(&renderer_);
EXPECT_EQ(0, renderer_.num_rendered_frames()); EXPECT_EQ(0, renderer_.num_rendered_frames());
SendFrame(); SendFrame();
EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
@ -1592,7 +1590,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
int fps) { int fps) {
EXPECT_TRUE(SetOneCodec(codec)); EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); channel_->SetDefaultSink(&renderer_);
EXPECT_EQ(0, renderer_.num_rendered_frames()); EXPECT_EQ(0, renderer_.num_rendered_frames());
for (int i = 0; i < duration_sec; ++i) { for (int i = 0; i < duration_sec; ++i) {
for (int frame = 1; frame <= fps; ++frame) { for (int frame = 1; frame <= fps; ++frame) {
@ -1984,12 +1982,12 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSink) {
rtc::CopyOnWriteBuffer packet1(data1, sizeof(data1)); rtc::CopyOnWriteBuffer packet1(data1, sizeof(data1));
rtc::SetBE32(packet1.data() + 8, kSsrc); rtc::SetBE32(packet1.data() + 8, kSsrc);
channel_->SetSink(kDefaultReceiveSsrc, NULL); channel_->SetDefaultSink(NULL);
EXPECT_TRUE(SetDefaultCodec()); EXPECT_TRUE(SetDefaultCodec());
EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(SetSend(true));
EXPECT_EQ(0, renderer_.num_rendered_frames()); EXPECT_EQ(0, renderer_.num_rendered_frames());
channel_->OnPacketReceived(packet1, /* packet_time_us */ -1); channel_->OnPacketReceived(packet1, /* packet_time_us */ -1);
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); channel_->SetDefaultSink(&renderer_);
SendFrame(); SendFrame();
EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
} }
@ -1998,7 +1996,7 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSink) {
TEST_F(WebRtcVideoChannelBaseTest, AddRemoveSendStreams) { TEST_F(WebRtcVideoChannelBaseTest, AddRemoveSendStreams) {
EXPECT_TRUE(SetOneCodec(DefaultCodec())); EXPECT_TRUE(SetOneCodec(DefaultCodec()));
EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); channel_->SetDefaultSink(&renderer_);
SendFrame(); SendFrame();
EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
EXPECT_GT(NumRtpPackets(), 0); EXPECT_GT(NumRtpPackets(), 0);
@ -2073,7 +2071,7 @@ TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) {
const int time_between_send_ms = VideoFormat::FpsToInterval(kFramerate); const int time_between_send_ms = VideoFormat::FpsToInterval(kFramerate);
EXPECT_TRUE(SetOneCodec(codec)); EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); channel_->SetDefaultSink(&renderer_);
EXPECT_EQ(0, renderer_.num_rendered_frames()); EXPECT_EQ(0, renderer_.num_rendered_frames());
SendFrame(); SendFrame();
EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
@ -2133,7 +2131,7 @@ TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) {
TEST_F(WebRtcVideoChannelBaseTest, RemoveCapturerWithoutAdd) { TEST_F(WebRtcVideoChannelBaseTest, RemoveCapturerWithoutAdd) {
EXPECT_TRUE(SetOneCodec(DefaultCodec())); EXPECT_TRUE(SetOneCodec(DefaultCodec()));
EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); channel_->SetDefaultSink(&renderer_);
EXPECT_EQ(0, renderer_.num_rendered_frames()); EXPECT_EQ(0, renderer_.num_rendered_frames());
SendFrame(); SendFrame();
EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout); EXPECT_FRAME_WAIT(1, kVideoWidth, kVideoHeight, kTimeout);
@ -5781,7 +5779,7 @@ TEST_F(WebRtcVideoChannelTest, ReceiveDifferentUnsignaledSsrc) {
// No receive streams yet. // No receive streams yet.
ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
cricket::FakeVideoRenderer renderer; cricket::FakeVideoRenderer renderer;
EXPECT_TRUE(channel_->SetSink(kDefaultRecvSsrc, &renderer)); channel_->SetDefaultSink(&renderer);
// Receive VP8 packet on first SSRC. // Receive VP8 packet on first SSRC.
uint8_t data[kMinRtpPacketLen]; uint8_t data[kMinRtpPacketLen];
@ -7478,10 +7476,12 @@ TEST_F(WebRtcVideoChannelTest, SetAndGetRtpReceiveParameters) {
EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(last_ssrc_)); EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(last_ssrc_));
} }
// Test that GetRtpReceiveParameters returns parameters correctly when SSRCs // Test that GetDefaultRtpReceiveParameters returns parameters correctly when
// aren't signaled. It should always return an empty "RtpEncodingParameters", // SSRCs aren't signaled. It should always return an empty
// even after a packet is received and the unsignaled SSRC is known. // "RtpEncodingParameters", even after a packet is received and the unsignaled
TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersWithUnsignaledSsrc) { // SSRC is known.
TEST_F(WebRtcVideoChannelTest,
GetDefaultRtpReceiveParametersWithUnsignaledSsrc) {
// Call necessary methods to configure receiving a default stream as // Call necessary methods to configure receiving a default stream as
// soon as it arrives. // soon as it arrives.
cricket::VideoRecvParameters parameters; cricket::VideoRecvParameters parameters;
@ -7491,16 +7491,16 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersWithUnsignaledSsrc) {
// Call GetRtpReceiveParameters before configured to receive an unsignaled // Call GetRtpReceiveParameters before configured to receive an unsignaled
// stream. Should return nothing. // stream. Should return nothing.
EXPECT_EQ(webrtc::RtpParameters(), channel_->GetRtpReceiveParameters(0)); EXPECT_EQ(webrtc::RtpParameters(),
channel_->GetDefaultRtpReceiveParameters());
// Set a sink for an unsignaled stream. // Set a sink for an unsignaled stream.
cricket::FakeVideoRenderer renderer; cricket::FakeVideoRenderer renderer;
// Value of "0" means "unsignaled stream". channel_->SetDefaultSink(&renderer);
EXPECT_TRUE(channel_->SetSink(0, &renderer));
// Call GetRtpReceiveParameters before the SSRC is known. Value of "0" // Call GetDefaultRtpReceiveParameters before the SSRC is known.
// in this method means "unsignaled stream". webrtc::RtpParameters rtp_parameters =
webrtc::RtpParameters rtp_parameters = channel_->GetRtpReceiveParameters(0); channel_->GetDefaultRtpReceiveParameters();
ASSERT_EQ(1u, rtp_parameters.encodings.size()); ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_FALSE(rtp_parameters.encodings[0].ssrc); EXPECT_FALSE(rtp_parameters.encodings[0].ssrc);
@ -7515,7 +7515,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersWithUnsignaledSsrc) {
channel_->OnPacketReceived(packet, /* packet_time_us */ -1); channel_->OnPacketReceived(packet, /* packet_time_us */ -1);
// The |ssrc| member should still be unset. // The |ssrc| member should still be unset.
rtp_parameters = channel_->GetRtpReceiveParameters(0); rtp_parameters = channel_->GetDefaultRtpReceiveParameters();
ASSERT_EQ(1u, rtp_parameters.encodings.size()); ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_FALSE(rtp_parameters.encodings[0].ssrc); EXPECT_FALSE(rtp_parameters.encodings[0].ssrc);
} }
@ -7780,7 +7780,7 @@ TEST_F(WebRtcVideoChannelSimulcastTest, SimulcastScreenshareWithoutConference) {
TEST_F(WebRtcVideoChannelBaseTest, GetSources) { TEST_F(WebRtcVideoChannelBaseTest, GetSources) {
EXPECT_THAT(channel_->GetSources(kSsrc), IsEmpty()); EXPECT_THAT(channel_->GetSources(kSsrc), IsEmpty());
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_)); channel_->SetDefaultSink(&renderer_);
EXPECT_TRUE(SetDefaultCodec()); EXPECT_TRUE(SetDefaultCodec());
EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(SetSend(true));
EXPECT_EQ(renderer_.num_rendered_frames(), 0); EXPECT_EQ(renderer_.num_rendered_frames(), 0);

89
media/engine/webrtc_voice_engine.cc
View File

@ -1423,26 +1423,32 @@ webrtc::RtpParameters WebRtcVoiceMediaChannel::GetRtpReceiveParameters(
uint32_t ssrc) const { uint32_t ssrc) const {
RTC_DCHECK(worker_thread_checker_.IsCurrent()); RTC_DCHECK(worker_thread_checker_.IsCurrent());
webrtc::RtpParameters rtp_params; webrtc::RtpParameters rtp_params;
// SSRC of 0 represents the default receive stream. auto it = recv_streams_.find(ssrc);
if (ssrc == 0) { if (it == recv_streams_.end()) {
if (!default_sink_) { RTC_LOG(LS_WARNING)
RTC_LOG(LS_WARNING) << "Attempting to get RTP receive parameters for stream "
<< "Attempting to get RTP parameters for the default, " << "with ssrc " << ssrc << " which doesn't exist.";
"unsignaled audio receive stream, but not yet " return webrtc::RtpParameters();
"configured to receive such a stream.";
return rtp_params;
}
rtp_params.encodings.emplace_back();
} else {
auto it = recv_streams_.find(ssrc);
if (it == recv_streams_.end()) {
RTC_LOG(LS_WARNING)
<< "Attempting to get RTP receive parameters for stream "
<< "with ssrc " << ssrc << " which doesn't exist.";
return webrtc::RtpParameters();
}
rtp_params = it->second->GetRtpParameters();
} }
rtp_params = it->second->GetRtpParameters();
for (const AudioCodec& codec : recv_codecs_) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
return rtp_params;
}
webrtc::RtpParameters WebRtcVoiceMediaChannel::GetDefaultRtpReceiveParameters()
const {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
webrtc::RtpParameters rtp_params;
if (!default_sink_) {
RTC_LOG(LS_WARNING) << "Attempting to get RTP parameters for the default, "
"unsignaled audio receive stream, but not yet "
"configured to receive such a stream.";
return rtp_params;
}
rtp_params.encodings.emplace_back();
for (const AudioCodec& codec : recv_codecs_) { for (const AudioCodec& codec : recv_codecs_) {
rtp_params.codecs.push_back(codec.ToCodecParameters()); rtp_params.codecs.push_back(codec.ToCodecParameters());
@ -1910,20 +1916,28 @@ bool WebRtcVoiceMediaChannel::SetLocalSource(uint32_t ssrc,
bool WebRtcVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) { bool WebRtcVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) {
RTC_DCHECK(worker_thread_checker_.IsCurrent()); RTC_DCHECK(worker_thread_checker_.IsCurrent());
std::vector<uint32_t> ssrcs(1, ssrc); const auto it = recv_streams_.find(ssrc);
// SSRC of 0 represents the default receive stream. if (it == recv_streams_.end()) {
if (ssrc == 0) { RTC_LOG(LS_WARNING) << "SetOutputVolume: no recv stream " << ssrc;
default_recv_volume_ = volume; return false;
ssrcs = unsignaled_recv_ssrcs_;
} }
for (uint32_t ssrc : ssrcs) { it->second->SetOutputVolume(volume);
RTC_LOG(LS_INFO) << "SetOutputVolume() to " << volume
<< " for recv stream with ssrc " << ssrc;
return true;
}
bool WebRtcVoiceMediaChannel::SetDefaultOutputVolume(double volume) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
default_recv_volume_ = volume;
for (uint32_t ssrc : unsignaled_recv_ssrcs_) {
const auto it = recv_streams_.find(ssrc); const auto it = recv_streams_.find(ssrc);
if (it == recv_streams_.end()) { if (it == recv_streams_.end()) {
RTC_LOG(LS_WARNING) << "SetOutputVolume: no recv stream " << ssrc; RTC_LOG(LS_WARNING) << "SetDefaultOutputVolume: no recv stream " << ssrc;
return false; return false;
} }
it->second->SetOutputVolume(volume); it->second->SetOutputVolume(volume);
RTC_LOG(LS_INFO) << "SetOutputVolume() to " << volume RTC_LOG(LS_INFO) << "SetDefaultOutputVolume() to " << volume
<< " for recv stream with ssrc " << ssrc; << " for recv stream with ssrc " << ssrc;
} }
return true; return true;
@ -2267,15 +2281,6 @@ void WebRtcVoiceMediaChannel::SetRawAudioSink(
RTC_DCHECK(worker_thread_checker_.IsCurrent()); RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::SetRawAudioSink: ssrc:" RTC_LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::SetRawAudioSink: ssrc:"
<< ssrc << " " << (sink ? "(ptr)" : "NULL"); << ssrc << " " << (sink ? "(ptr)" : "NULL");
if (ssrc == 0) {
if (!unsignaled_recv_ssrcs_.empty()) {
std::unique_ptr<webrtc::AudioSinkInterface> proxy_sink(
sink ? new ProxySink(sink.get()) : nullptr);
SetRawAudioSink(unsignaled_recv_ssrcs_.back(), std::move(proxy_sink));
}
default_sink_ = std::move(sink);
return;
}
const auto it = recv_streams_.find(ssrc); const auto it = recv_streams_.find(ssrc);
if (it == recv_streams_.end()) { if (it == recv_streams_.end()) {
RTC_LOG(LS_WARNING) << "SetRawAudioSink: no recv stream " << ssrc; RTC_LOG(LS_WARNING) << "SetRawAudioSink: no recv stream " << ssrc;
@ -2284,6 +2289,18 @@ void WebRtcVoiceMediaChannel::SetRawAudioSink(
it->second->SetRawAudioSink(std::move(sink)); it->second->SetRawAudioSink(std::move(sink));
} }
void WebRtcVoiceMediaChannel::SetDefaultRawAudioSink(
std::unique_ptr<webrtc::AudioSinkInterface> sink) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::SetDefaultRawAudioSink:";
if (!unsignaled_recv_ssrcs_.empty()) {
std::unique_ptr<webrtc::AudioSinkInterface> proxy_sink(
sink ? new ProxySink(sink.get()) : nullptr);
SetRawAudioSink(unsignaled_recv_ssrcs_.back(), std::move(proxy_sink));
}
default_sink_ = std::move(sink);
}
std::vector<webrtc::RtpSource> WebRtcVoiceMediaChannel::GetSources( std::vector<webrtc::RtpSource> WebRtcVoiceMediaChannel::GetSources(
uint32_t ssrc) const { uint32_t ssrc) const {
auto it = recv_streams_.find(ssrc); auto it = recv_streams_.find(ssrc);

11
media/engine/webrtc_voice_engine.h
View File

@ -151,6 +151,7 @@ class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
uint32_t ssrc, uint32_t ssrc,
const webrtc::RtpParameters& parameters) override; const webrtc::RtpParameters& parameters) override;
webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override; webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override;
webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override;
void SetPlayout(bool playout) override; void SetPlayout(bool playout) override;
void SetSend(bool send) override; void SetSend(bool send) override;
@ -178,8 +179,9 @@ class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
rtc::scoped_refptr<webrtc::FrameEncryptorInterface> rtc::scoped_refptr<webrtc::FrameEncryptorInterface>
frame_encryptor) override; frame_encryptor) override;
// SSRC=0 will apply the new volume to current and future unsignaled streams.
bool SetOutputVolume(uint32_t ssrc, double volume) override; bool SetOutputVolume(uint32_t ssrc, double volume) override;
// Applies the new volume to current and future unsignaled streams.
bool SetDefaultOutputVolume(double volume) override;
bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override; bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override;
absl::optional<int> GetBaseMinimumPlayoutDelayMs( absl::optional<int> GetBaseMinimumPlayoutDelayMs(
@ -195,11 +197,14 @@ class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
void OnReadyToSend(bool ready) override; void OnReadyToSend(bool ready) override;
bool GetStats(VoiceMediaInfo* info) override; bool GetStats(VoiceMediaInfo* info) override;
// SSRC=0 will set the audio sink on the latest unsignaled stream, future or // Set the audio sink for an existing stream.
// current. Only one stream at a time will use the sink.
void SetRawAudioSink( void SetRawAudioSink(
uint32_t ssrc, uint32_t ssrc,
std::unique_ptr<webrtc::AudioSinkInterface> sink) override; std::unique_ptr<webrtc::AudioSinkInterface> sink) override;
// Will set the audio sink on the latest unsignaled stream, future or
// current. Only one stream at a time will use the sink.
void SetDefaultRawAudioSink(
std::unique_ptr<webrtc::AudioSinkInterface> sink) override;
std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override; std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override;

34
media/engine/webrtc_voice_engine_unittest.cc
View File

@ -1392,18 +1392,18 @@ TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) {
parameters.codecs.push_back(kPcmuCodec); parameters.codecs.push_back(kPcmuCodec);
EXPECT_TRUE(channel_->SetRecvParameters(parameters)); EXPECT_TRUE(channel_->SetRecvParameters(parameters));
// Call GetRtpReceiveParameters before configured to receive an unsignaled // Call GetDefaultRtpReceiveParameters before configured to receive an
// stream. Should return nothing. // unsignaled stream. Should return nothing.
EXPECT_EQ(webrtc::RtpParameters(), channel_->GetRtpReceiveParameters(0)); EXPECT_EQ(webrtc::RtpParameters(),
channel_->GetDefaultRtpReceiveParameters());
// Set a sink for an unsignaled stream. // Set a sink for an unsignaled stream.
std::unique_ptr<FakeAudioSink> fake_sink(new FakeAudioSink()); std::unique_ptr<FakeAudioSink> fake_sink(new FakeAudioSink());
// Value of "0" means "unsignaled stream". channel_->SetDefaultRawAudioSink(std::move(fake_sink));
channel_->SetRawAudioSink(0, std::move(fake_sink));
// Call GetRtpReceiveParameters before the SSRC is known. Value of "0" // Call GetDefaultRtpReceiveParameters before the SSRC is known.
// in this method means "unsignaled stream". webrtc::RtpParameters rtp_parameters =
webrtc::RtpParameters rtp_parameters = channel_->GetRtpReceiveParameters(0); channel_->GetDefaultRtpReceiveParameters();
ASSERT_EQ(1u, rtp_parameters.encodings.size()); ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_FALSE(rtp_parameters.encodings[0].ssrc); EXPECT_FALSE(rtp_parameters.encodings[0].ssrc);
@ -1411,7 +1411,7 @@ TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) {
DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
// The |ssrc| member should still be unset. // The |ssrc| member should still be unset.
rtp_parameters = channel_->GetRtpReceiveParameters(0); rtp_parameters = channel_->GetDefaultRtpReceiveParameters();
ASSERT_EQ(1u, rtp_parameters.encodings.size()); ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_FALSE(rtp_parameters.encodings[0].ssrc); EXPECT_FALSE(rtp_parameters.encodings[0].ssrc);
} }
@ -3104,7 +3104,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolumeUnsignaledRecvStream) {
// Should remember the volume "2" which will be set on new unsignaled streams, // Should remember the volume "2" which will be set on new unsignaled streams,
// and also set the gain to 2 on existing unsignaled streams. // and also set the gain to 2 on existing unsignaled streams.
EXPECT_TRUE(channel_->SetOutputVolume(kSsrc0, 2)); EXPECT_TRUE(channel_->SetDefaultOutputVolume(2));
EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrc1).gain()); EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrc1).gain());
// Spawn an unsignaled stream by sending a packet - gain should be 2. // Spawn an unsignaled stream by sending a packet - gain should be 2.
@ -3114,8 +3114,8 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolumeUnsignaledRecvStream) {
DeliverPacket(pcmuFrame2, sizeof(pcmuFrame2)); DeliverPacket(pcmuFrame2, sizeof(pcmuFrame2));
EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrcX).gain()); EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrcX).gain());
// Setting gain with SSRC=0 should affect all unsignaled streams. // Setting gain for all unsignaled streams.
EXPECT_TRUE(channel_->SetOutputVolume(kSsrc0, 3)); EXPECT_TRUE(channel_->SetDefaultOutputVolume(3));
if (kMaxUnsignaledRecvStreams > 1) { if (kMaxUnsignaledRecvStreams > 1) {
EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain()); EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain());
} }
@ -3341,7 +3341,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkUnsignaledRecvStream) {
std::unique_ptr<FakeAudioSink> fake_sink_4(new FakeAudioSink()); std::unique_ptr<FakeAudioSink> fake_sink_4(new FakeAudioSink());
// Should be able to set a default sink even when no stream exists. // Should be able to set a default sink even when no stream exists.
channel_->SetRawAudioSink(0, std::move(fake_sink_1)); channel_->SetDefaultRawAudioSink(std::move(fake_sink_1));
// Spawn an unsignaled stream by sending a packet - it should be assigned the // Spawn an unsignaled stream by sending a packet - it should be assigned the
// default sink. // default sink.
@ -3349,11 +3349,11 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkUnsignaledRecvStream) {
EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
// Try resetting the default sink. // Try resetting the default sink.
channel_->SetRawAudioSink(kSsrc0, nullptr); channel_->SetDefaultRawAudioSink(nullptr);
EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
// Try setting the default sink while the default stream exists. // Try setting the default sink while the default stream exists.
channel_->SetRawAudioSink(kSsrc0, std::move(fake_sink_2)); channel_->SetDefaultRawAudioSink(std::move(fake_sink_2));
EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
// If we remove and add a default stream, it should get the same sink. // If we remove and add a default stream, it should get the same sink.
@ -3373,14 +3373,14 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkUnsignaledRecvStream) {
EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink()); EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink());
// Reset the default sink - the second unsignaled stream should lose it. // Reset the default sink - the second unsignaled stream should lose it.
channel_->SetRawAudioSink(kSsrc0, nullptr); channel_->SetDefaultRawAudioSink(nullptr);
if (kMaxUnsignaledRecvStreams > 1) { if (kMaxUnsignaledRecvStreams > 1) {
EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
} }
EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink()); EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink());
// Try setting the default sink while two streams exists. // Try setting the default sink while two streams exists.
channel_->SetRawAudioSink(kSsrc0, std::move(fake_sink_3)); channel_->SetDefaultRawAudioSink(std::move(fake_sink_3));
if (kMaxUnsignaledRecvStreams > 1) { if (kMaxUnsignaledRecvStreams > 1) {
EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
} }

12
pc/audio_rtp_receiver.cc
View File

@ -76,8 +76,8 @@ bool AudioRtpReceiver::SetOutputVolume(double volume) {
RTC_DCHECK(media_channel_); RTC_DCHECK(media_channel_);
RTC_DCHECK(!stopped_); RTC_DCHECK(!stopped_);
return worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] { return worker_thread_->Invoke<bool>(RTC_FROM_HERE, [&] {
// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC value. return ssrc_ ? media_channel_->SetOutputVolume(*ssrc_, volume)
return media_channel_->SetOutputVolume(ssrc_.value_or(0), volume); : media_channel_->SetDefaultOutputVolume(volume);
}); });
} }
@ -112,8 +112,8 @@ RtpParameters AudioRtpReceiver::GetParameters() const {
return RtpParameters(); return RtpParameters();
} }
return worker_thread_->Invoke<RtpParameters>(RTC_FROM_HERE, [&] { return worker_thread_->Invoke<RtpParameters>(RTC_FROM_HERE, [&] {
// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC value. return ssrc_ ? media_channel_->GetRtpReceiveParameters(*ssrc_)
return media_channel_->GetRtpReceiveParameters(ssrc_.value_or(0)); : media_channel_->GetDefaultRtpReceiveParameters();
}); });
} }
@ -153,12 +153,12 @@ void AudioRtpReceiver::RestartMediaChannel(absl::optional<uint32_t> ssrc) {
} }
if (!stopped_) { if (!stopped_) {
source_->Stop(media_channel_, ssrc_.value_or(0)); source_->Stop(media_channel_, ssrc_);
delay_->OnStop(); delay_->OnStop();
} }
ssrc_ = ssrc; ssrc_ = ssrc;
stopped_ = false; stopped_ = false;
source_->Start(media_channel_, ssrc.value_or(0)); source_->Start(media_channel_, ssrc);
delay_->OnStart(media_channel_, ssrc.value_or(0)); delay_->OnStart(media_channel_, ssrc.value_or(0));
Reconfigure(); Reconfigure();
} }

16
pc/remote_audio_source.cc
View File

@ -63,7 +63,7 @@ RemoteAudioSource::~RemoteAudioSource() {
} }
void RemoteAudioSource::Start(cricket::VoiceMediaChannel* media_channel, void RemoteAudioSource::Start(cricket::VoiceMediaChannel* media_channel,
uint32_t ssrc) { absl::optional<uint32_t> ssrc) {
RTC_DCHECK_RUN_ON(main_thread_); RTC_DCHECK_RUN_ON(main_thread_);
RTC_DCHECK(media_channel); RTC_DCHECK(media_channel);
@ -71,18 +71,22 @@ void RemoteAudioSource::Start(cricket::VoiceMediaChannel* media_channel,
// notified when a channel goes out of scope (signaled when "AudioDataProxy" // notified when a channel goes out of scope (signaled when "AudioDataProxy"
// is destroyed). // is destroyed).
worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] { worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
media_channel->SetRawAudioSink(ssrc, ssrc ? media_channel->SetRawAudioSink(
std::make_unique<AudioDataProxy>(this)); *ssrc, std::make_unique<AudioDataProxy>(this))
: media_channel->SetDefaultRawAudioSink(
std::make_unique<AudioDataProxy>(this));
}); });
} }
void RemoteAudioSource::Stop(cricket::VoiceMediaChannel* media_channel, void RemoteAudioSource::Stop(cricket::VoiceMediaChannel* media_channel,
uint32_t ssrc) { absl::optional<uint32_t> ssrc) {
RTC_DCHECK_RUN_ON(main_thread_); RTC_DCHECK_RUN_ON(main_thread_);
RTC_DCHECK(media_channel); RTC_DCHECK(media_channel);
worker_thread_->Invoke<void>( worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
RTC_FROM_HERE, [&] { media_channel->SetRawAudioSink(ssrc, nullptr); }); ssrc ? media_channel->SetRawAudioSink(*ssrc, nullptr)
: media_channel->SetDefaultRawAudioSink(nullptr);
});
} }
MediaSourceInterface::SourceState RemoteAudioSource::state() const { MediaSourceInterface::SourceState RemoteAudioSource::state() const {

7
pc/remote_audio_source.h
View File

@ -14,6 +14,7 @@
#include <list> #include <list>
#include <string> #include <string>
#include "absl/types/optional.h"
#include "api/call/audio_sink.h" #include "api/call/audio_sink.h"
#include "api/notifier.h" #include "api/notifier.h"
#include "pc/channel.h" #include "pc/channel.h"
@ -37,8 +38,10 @@ class RemoteAudioSource : public Notifier<AudioSourceInterface>,
// Register and unregister remote audio source with the underlying media // Register and unregister remote audio source with the underlying media
// engine. // engine.
void Start(cricket::VoiceMediaChannel* media_channel, uint32_t ssrc); void Start(cricket::VoiceMediaChannel* media_channel,
void Stop(cricket::VoiceMediaChannel* media_channel, uint32_t ssrc); absl::optional<uint32_t> ssrc);
void Stop(cricket::VoiceMediaChannel* media_channel,
absl::optional<uint32_t> ssrc);
// MediaSourceInterface implementation. // MediaSourceInterface implementation.
MediaSourceInterface::SourceState state() const override; MediaSourceInterface::SourceState state() const override;

11
pc/video_rtp_receiver.cc
View File

@ -83,8 +83,8 @@ RtpParameters VideoRtpReceiver::GetParameters() const {
return RtpParameters(); return RtpParameters();
} }
return worker_thread_->Invoke<RtpParameters>(RTC_FROM_HERE, [&] { return worker_thread_->Invoke<RtpParameters>(RTC_FROM_HERE, [&] {
// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC return ssrc_ ? media_channel_->GetRtpReceiveParameters(*ssrc_)
return media_channel_->GetRtpReceiveParameters(ssrc_.value_or(0)); : media_channel_->GetDefaultRtpReceiveParameters();
}); });
} }
@ -155,8 +155,11 @@ void VideoRtpReceiver::RestartMediaChannel(absl::optional<uint32_t> ssrc) {
} }
void VideoRtpReceiver::SetSink(rtc::VideoSinkInterface<VideoFrame>* sink) { void VideoRtpReceiver::SetSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
// TODO(bugs.webrtc.org/8694): Stop using 0 to mean unsignalled SSRC if (ssrc_) {
media_channel_->SetSink(ssrc_.value_or(0), sink); media_channel_->SetSink(*ssrc_, sink);
return;
}
media_channel_->SetDefaultSink(sink);
} }
void VideoRtpReceiver::SetupMediaChannel(uint32_t ssrc) { void VideoRtpReceiver::SetupMediaChannel(uint32_t ssrc) {