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

Delete a few return values from audio streams and video send streams.

Browse Source 
Bug: webrtc:10198
Change-Id: I583dbb717aea26c9d282a3786062d285121fbf66
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/125723
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Fredrik Solenberg <solenberg@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26986}
This commit is contained in:
Niels Möller
2019-03-05 14:29:42 +01:00
committed by Commit Bot
parent 0da25a1c8e
commit 8fb1a6ad27
16 changed files with 45 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
audio/audio_receive_stream.cc
View File

@ -310,12 +310,12 @@ void AudioReceiveStream::SignalNetworkState(NetworkState state) {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
}
bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
void AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!thread_checker_.CalledOnValidThread());
return channel_receive_->ReceivedRTCPPacket(packet, length);
channel_receive_->ReceivedRTCPPacket(packet, length);
}
void AudioReceiveStream::OnRtpPacket(const RtpPacketReceived& packet) {

2
audio/audio_receive_stream.h
View File

@ -91,7 +91,7 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream,
void AssociateSendStream(AudioSendStream* send_stream);
void SignalNetworkState(NetworkState state);
bool DeliverRtcp(const uint8_t* packet, size_t length);
void DeliverRtcp(const uint8_t* packet, size_t length);
const webrtc::AudioReceiveStream::Config& config() const;
const AudioSendStream* GetAssociatedSendStreamForTesting() const;

4
audio/audio_receive_stream_unittest.cc
View File

@ -255,8 +255,8 @@ TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) {
std::vector<uint8_t> rtcp_packet = CreateRtcpSenderReport();
EXPECT_CALL(*helper.channel_receive(),
ReceivedRTCPPacket(&rtcp_packet[0], rtcp_packet.size()))
.WillOnce(Return(true));
EXPECT_TRUE(recv_stream->DeliverRtcp(&rtcp_packet[0], rtcp_packet.size()));
.WillOnce(Return());
recv_stream->DeliverRtcp(&rtcp_packet[0], rtcp_packet.size());
}
TEST(AudioReceiveStreamTest, GetStats) {

10
audio/audio_send_stream.cc
View File

@ -353,9 +353,9 @@ bool AudioSendStream::SendTelephoneEvent(int payload_type,
int event,
int duration_ms) {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
return channel_send_->SetSendTelephoneEventPayloadType(payload_type,
payload_frequency) &&
channel_send_->SendTelephoneEventOutband(event, duration_ms);
channel_send_->SetSendTelephoneEventPayloadType(payload_type,
payload_frequency);
return channel_send_->SendTelephoneEventOutband(event, duration_ms);
}
void AudioSendStream::SetMuted(bool muted) {
@ -422,12 +422,12 @@ void AudioSendStream::SignalNetworkState(NetworkState state) {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
}
bool AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
void AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!worker_thread_checker_.CalledOnValidThread());
return channel_send_->ReceivedRTCPPacket(packet, length);
channel_send_->ReceivedRTCPPacket(packet, length);
}
uint32_t AudioSendStream::OnBitrateUpdated(BitrateAllocationUpdate update) {

2
audio/audio_send_stream.h
View File

@ -78,7 +78,7 @@ class AudioSendStream final : public webrtc::AudioSendStream,
bool has_remote_tracks) const override;
void SignalNetworkState(NetworkState state);
bool DeliverRtcp(const uint8_t* packet, size_t length);
void DeliverRtcp(const uint8_t* packet, size_t length);
// Implements BitrateAllocatorObserver.
uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) override;

5
audio/audio_send_stream_unittest.cc
View File

@ -240,8 +240,7 @@ struct ConfigHelper {
EXPECT_TRUE(channel_send_);
EXPECT_CALL(*channel_send_, SetSendTelephoneEventPayloadType(
kTelephoneEventPayloadType,
kTelephoneEventPayloadFrequency))
.WillOnce(Return(true));
kTelephoneEventPayloadFrequency));
EXPECT_CALL(
*channel_send_,
SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration))
@ -500,7 +499,7 @@ TEST(AudioSendStreamTest, DontRecreateEncoder) {
// to ConfigHelper (say to WillRepeatedly) would silently make this test
// useless.
EXPECT_CALL(*helper.channel_send(), SetEncoderForMock(_, _))
.WillOnce(Return(true));
.WillOnce(Return());
helper.config().send_codec_spec =
AudioSendStream::Config::SendCodecSpec(9, kG722Format);

10
audio/channel_receive.cc
View File

@ -106,7 +106,7 @@ class ChannelReceive : public ChannelReceiveInterface,
absl::optional<std::pair<int, SdpAudioFormat>>
GetReceiveCodec() const override;
bool ReceivedRTCPPacket(const uint8_t* data, size_t length) override;
void ReceivedRTCPPacket(const uint8_t* data, size_t length) override;
// RtpPacketSinkInterface.
void OnRtpPacket(const RtpPacketReceived& packet) override;
@ -664,8 +664,7 @@ bool ChannelReceive::ReceivePacket(const uint8_t* packet,
}
// May be called on either worker thread or network thread.
// TODO(nisse): Drop always-true return value.
bool ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
void ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
// Store playout timestamp for the received RTCP packet
UpdatePlayoutTimestamp(true);
@ -675,7 +674,7 @@ bool ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
int64_t rtt = GetRTT();
if (rtt == 0) {
// Waiting for valid RTT.
return true;
return;
}
uint32_t ntp_secs = 0;
@ -684,14 +683,13 @@ bool ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
if (0 != _rtpRtcpModule->RemoteNTP(&ntp_secs, &ntp_frac, NULL, NULL,
&rtp_timestamp)) {
// Waiting for RTCP.
return true;
return;
}
{
rtc::CritScope lock(&ts_stats_lock_);
ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
}
return true;
}
int ChannelReceive::GetSpeechOutputLevelFullRange() const {

2
audio/channel_receive.h
View File

@ -84,7 +84,7 @@ class ChannelReceiveInterface : public RtpPacketSinkInterface {
virtual absl::optional<std::pair<int, SdpAudioFormat>>
GetReceiveCodec() const = 0;
virtual bool ReceivedRTCPPacket(const uint8_t* data, size_t length) = 0;
virtual void ReceivedRTCPPacket(const uint8_t* data, size_t length) = 0;
virtual void SetChannelOutputVolumeScaling(float scaling) = 0;
virtual int GetSpeechOutputLevelFullRange() const = 0;

20
audio/channel_send.cc
View File

@ -103,7 +103,7 @@ class ChannelSend
~ChannelSend() override;
// Send using this encoder, with this payload type.
bool SetEncoder(int payload_type,
void SetEncoder(int payload_type,
std::unique_ptr<AudioEncoder> encoder) override;
void ModifyEncoder(rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)>
modifier) override;
@ -118,7 +118,7 @@ class ChannelSend
int GetBitrate() const override;
// Network
bool ReceivedRTCPPacket(const uint8_t* data, size_t length) override;
void ReceivedRTCPPacket(const uint8_t* data, size_t length) override;
// Muting, Volume and Level.
void SetInputMute(bool enable) override;
@ -131,7 +131,7 @@ class ChannelSend
// DTMF.
bool SendTelephoneEventOutband(int event, int duration_ms) override;
bool SetSendTelephoneEventPayloadType(int payload_type,
void SetSendTelephoneEventPayloadType(int payload_type,
int payload_frequency) override;
// RTP+RTCP
@ -789,7 +789,7 @@ void ChannelSend::StopSend() {
_rtpRtcpModule->SetSendingMediaStatus(false);
}
bool ChannelSend::SetEncoder(int payload_type,
void ChannelSend::SetEncoder(int payload_type,
std::unique_ptr<AudioEncoder> encoder) {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
RTC_DCHECK_GE(payload_type, 0);
@ -811,7 +811,6 @@ bool ChannelSend::SetEncoder(int payload_type,
media_transport_sampling_frequency_ = encoder->RtpTimestampRateHz();
}
audio_coding_->SetEncoder(std::move(encoder));
return true;
}
void ChannelSend::ModifyEncoder(
@ -879,13 +878,12 @@ void ChannelSend::OnUplinkPacketLossRate(float packet_loss_rate) {
});
}
// TODO(nisse): Delete always-true return value.
bool ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
void ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
// May be called on either worker thread or network thread.
if (media_transport_) {
// Ignore RTCP packets while media transport is used.
// Those packets should not arrive, but we are seeing occasional packets.
return 0;
return;
}
// Deliver RTCP packet to RTP/RTCP module for parsing
@ -894,7 +892,7 @@ bool ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
int64_t rtt = GetRTT();
if (rtt == 0) {
// Waiting for valid RTT.
return true;
return;
}
int64_t nack_window_ms = rtt;
@ -906,7 +904,6 @@ bool ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
retransmission_rate_limiter_->SetWindowSize(nack_window_ms);
OnReceivedRtt(rtt);
return true;
}
void ChannelSend::SetInputMute(bool enable) {
@ -937,14 +934,13 @@ bool ChannelSend::SendTelephoneEventOutband(int event, int duration_ms) {
return true;
}
bool ChannelSend::SetSendTelephoneEventPayloadType(int payload_type,
void ChannelSend::SetSendTelephoneEventPayloadType(int payload_type,
int payload_frequency) {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
RTC_DCHECK_LE(0, payload_type);
RTC_DCHECK_GE(127, payload_type);
_rtpRtcpModule->RegisterAudioSendPayload(payload_type, "telephone-event",
payload_frequency, 0, 0);
return true;
}
void ChannelSend::SetLocalSSRC(uint32_t ssrc) {

6
audio/channel_send.h
View File

@ -55,11 +55,11 @@ class ChannelSendInterface {
public:
virtual ~ChannelSendInterface() = default;
virtual bool ReceivedRTCPPacket(const uint8_t* packet, size_t length) = 0;
virtual void ReceivedRTCPPacket(const uint8_t* packet, size_t length) = 0;
virtual CallSendStatistics GetRTCPStatistics() const = 0;
virtual bool SetEncoder(int payload_type,
virtual void SetEncoder(int payload_type,
std::unique_ptr<AudioEncoder> encoder) = 0;
virtual void ModifyEncoder(
rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier) = 0;
@ -81,7 +81,7 @@ class ChannelSendInterface {
virtual void ResetSenderCongestionControlObjects() = 0;
virtual std::vector<ReportBlock> GetRemoteRTCPReportBlocks() const = 0;
virtual ANAStats GetANAStatistics() const = 0;
virtual bool SetSendTelephoneEventPayloadType(int payload_type,
virtual void SetSendTelephoneEventPayloadType(int payload_type,
int payload_frequency) = 0;
virtual bool SendTelephoneEventOutband(int event, int duration_ms) = 0;
virtual void OnBitrateAllocation(BitrateAllocationUpdate update) = 0;

10
audio/mock_voe_channel_proxy.h
View File

@ -42,7 +42,7 @@ class MockChannelReceive : public voe::ChannelReceiveInterface {
MOCK_CONST_METHOD0(GetDelayEstimate, uint32_t());
MOCK_METHOD1(SetSink, void(AudioSinkInterface* sink));
MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived& packet));
MOCK_METHOD2(ReceivedRTCPPacket, bool(const uint8_t* packet, size_t length));
MOCK_METHOD2(ReceivedRTCPPacket, void(const uint8_t* packet, size_t length));
MOCK_METHOD1(SetChannelOutputVolumeScaling, void(float scaling));
MOCK_METHOD2(GetAudioFrameWithInfo,
AudioMixer::Source::AudioFrameInfo(int sample_rate_hz,
@ -67,12 +67,12 @@ class MockChannelReceive : public voe::ChannelReceiveInterface {
class MockChannelSend : public voe::ChannelSendInterface {
public:
// GMock doesn't like move-only types, like std::unique_ptr.
virtual bool SetEncoder(int payload_type,
virtual void SetEncoder(int payload_type,
std::unique_ptr<AudioEncoder> encoder) {
return SetEncoderForMock(payload_type, &encoder);
}
MOCK_METHOD2(SetEncoderForMock,
bool(int payload_type, std::unique_ptr<AudioEncoder>* encoder));
void(int payload_type, std::unique_ptr<AudioEncoder>* encoder));
MOCK_METHOD1(
ModifyEncoder,
void(rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier));
@ -96,11 +96,11 @@ class MockChannelSend : public voe::ChannelSendInterface {
MOCK_CONST_METHOD0(GetRemoteRTCPReportBlocks, std::vector<ReportBlock>());
MOCK_CONST_METHOD0(GetANAStatistics, ANAStats());
MOCK_METHOD2(SetSendTelephoneEventPayloadType,
bool(int payload_type, int payload_frequency));
void(int payload_type, int payload_frequency));
MOCK_METHOD2(SendTelephoneEventOutband, bool(int event, int duration_ms));
MOCK_METHOD1(OnBitrateAllocation, void(BitrateAllocationUpdate update));
MOCK_METHOD1(SetInputMute, void(bool muted));
MOCK_METHOD2(ReceivedRTCPPacket, bool(const uint8_t* packet, size_t length));
MOCK_METHOD2(ReceivedRTCPPacket, void(const uint8_t* packet, size_t length));
// GMock doesn't like move-only types, like std::unique_ptr.
virtual void ProcessAndEncodeAudio(std::unique_ptr<AudioFrame> audio_frame) {
ProcessAndEncodeAudioForMock(&audio_frame);

12
call/call.cc
View File

@ -1292,22 +1292,22 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
ReadLockScoped read_lock(*receive_crit_);
for (AudioReceiveStream* stream : audio_receive_streams_) {
if (stream->DeliverRtcp(packet, length))
rtcp_delivered = true;
stream->DeliverRtcp(packet, length);
rtcp_delivered = true;
}
}
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
ReadLockScoped read_lock(*send_crit_);
for (VideoSendStream* stream : video_send_streams_) {
if (stream->DeliverRtcp(packet, length))
rtcp_delivered = true;
stream->DeliverRtcp(packet, length);
rtcp_delivered = true;
}
}
if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
ReadLockScoped read_lock(*send_crit_);
for (auto& kv : audio_send_ssrcs_) {
if (kv.second->DeliverRtcp(packet, length))
rtcp_delivered = true;
kv.second->DeliverRtcp(packet, length);
rtcp_delivered = true;
}
}

4
video/video_send_stream.cc
View File

@ -207,9 +207,9 @@ void VideoSendStream::StopPermanentlyAndGetRtpStates(
thread_sync_event_.Wait(rtc::Event::kForever);
}
bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
void VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// Called on a network thread.
return send_stream_->DeliverRtcp(packet, length);
send_stream_->DeliverRtcp(packet, length);
}
} // namespace internal

2
video/video_send_stream.h
View File

@ -71,7 +71,7 @@ class VideoSendStream : public webrtc::VideoSendStream {
~VideoSendStream() override;
bool DeliverRtcp(const uint8_t* packet, size_t length);
void DeliverRtcp(const uint8_t* packet, size_t length);
// webrtc::VideoSendStream implementation.
void UpdateActiveSimulcastLayers(

3
video/video_send_stream_impl.cc
View File

@ -350,11 +350,10 @@ void VideoSendStreamImpl::DeRegisterProcessThread() {
rtp_video_sender_->DeRegisterProcessThread();
}
bool VideoSendStreamImpl::DeliverRtcp(const uint8_t* packet, size_t length) {
void VideoSendStreamImpl::DeliverRtcp(const uint8_t* packet, size_t length) {
// Runs on a network thread.
RTC_DCHECK(!worker_queue_->IsCurrent());
rtp_video_sender_->DeliverRtcp(packet, length);
return true;
}
void VideoSendStreamImpl::UpdateActiveSimulcastLayers(

2
video/video_send_stream_impl.h
View File

@ -97,7 +97,7 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
void RegisterProcessThread(ProcessThread* module_process_thread);
void DeRegisterProcessThread();
bool DeliverRtcp(const uint8_t* packet, size_t length);
void DeliverRtcp(const uint8_t* packet, size_t length);
void UpdateActiveSimulcastLayers(const std::vector<bool> active_layers);
void Start();
void Stop();