From 1ba8d39a9cee4d8771faa440ac4d2978170fc8ea Mon Sep 17 00:00:00 2001 From: pbos Date: Sun, 1 May 2016 20:18:34 -0700 Subject: [PATCH] Remove webrtc/stream.h and unutilized inheritance. Removes inheritance and a virtual call. Also removes a root header that would have needed to be moved into a subdirectory otherwise to prevent circular dependencies. BUG=webrtc:4243 R=kjellander@webrtc.org, solenberg@webrtc.org TBR=mflodman@webrtc.org Review-Url: https://codereview.webrtc.org/1924793002 Cr-Commit-Position: refs/heads/master@{#12586} --- webrtc/DEPS | 1 - webrtc/audio/audio_receive_stream.cc | 80 +++++++++---------- webrtc/audio/audio_receive_stream.h | 15 ++-- webrtc/audio/audio_send_stream.cc | 24 +++--- webrtc/audio/audio_send_stream.h | 8 +- webrtc/audio_receive_stream.h | 14 +++- webrtc/audio_send_stream.h | 13 ++- webrtc/common_types.h | 5 ++ webrtc/media/engine/fakewebrtccall.cc | 4 - webrtc/media/engine/fakewebrtccall.h | 36 ++------- .../include/congestion_controller.h | 2 +- webrtc/stream.h | 56 ------------- webrtc/video/video_receive_stream.cc | 31 +++---- webrtc/video/video_receive_stream.h | 12 +-- webrtc/video/video_send_stream.cc | 46 +++++------ webrtc/video/video_send_stream.h | 9 +-- webrtc/video_receive_stream.h | 13 ++- webrtc/video_send_stream.h | 13 ++- webrtc/webrtc.gyp | 1 - 19 files changed, 167 insertions(+), 216 deletions(-) delete mode 100644 webrtc/stream.h diff --git a/webrtc/DEPS b/webrtc/DEPS index ab08fbf733..40ec7a3d62 100644 --- a/webrtc/DEPS +++ b/webrtc/DEPS @@ -19,7 +19,6 @@ include_rules = [ "+webrtc/common_types.h", "+webrtc/config.h", "+webrtc/engine_configurations.h", - "+webrtc/stream.h", "+webrtc/transport.h", "+webrtc/typedefs.h", "+webrtc/video_decoder.h", diff --git a/webrtc/audio/audio_receive_stream.cc b/webrtc/audio/audio_receive_stream.cc index 449f2f492f..f984c7fb20 100644 --- a/webrtc/audio/audio_receive_stream.cc +++ b/webrtc/audio/audio_receive_stream.cc @@ -143,46 +143,6 @@ void AudioReceiveStream::Stop() { RTC_DCHECK(thread_checker_.CalledOnValidThread()); } -void AudioReceiveStream::SignalNetworkState(NetworkState state) { - RTC_DCHECK(thread_checker_.CalledOnValidThread()); -} - -bool 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_proxy_->ReceivedRTCPPacket(packet, length); -} - -bool AudioReceiveStream::DeliverRtp(const uint8_t* packet, - size_t length, - const PacketTime& packet_time) { - // 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()); - RTPHeader header; - if (!rtp_header_parser_->Parse(packet, length, &header)) { - return false; - } - - // Only forward if the parsed header has one of the headers necessary for - // bandwidth estimation. RTP timestamps has different rates for audio and - // video and shouldn't be mixed. - if (remote_bitrate_estimator_ && - header.extension.hasTransportSequenceNumber) { - int64_t arrival_time_ms = TickTime::MillisecondTimestamp(); - if (packet_time.timestamp >= 0) - arrival_time_ms = (packet_time.timestamp + 500) / 1000; - size_t payload_size = length - header.headerLength; - remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size, - header, false); - } - - return channel_proxy_->ReceivedRTPPacket(packet, length, packet_time); -} - webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats() const { RTC_DCHECK(thread_checker_.CalledOnValidThread()); webrtc::AudioReceiveStream::Stats stats; @@ -241,6 +201,46 @@ const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const { return config_; } +void AudioReceiveStream::SignalNetworkState(NetworkState state) { + RTC_DCHECK(thread_checker_.CalledOnValidThread()); +} + +bool 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_proxy_->ReceivedRTCPPacket(packet, length); +} + +bool AudioReceiveStream::DeliverRtp(const uint8_t* packet, + size_t length, + const PacketTime& packet_time) { + // 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()); + RTPHeader header; + if (!rtp_header_parser_->Parse(packet, length, &header)) { + return false; + } + + // Only forward if the parsed header has one of the headers necessary for + // bandwidth estimation. RTP timestamps has different rates for audio and + // video and shouldn't be mixed. + if (remote_bitrate_estimator_ && + header.extension.hasTransportSequenceNumber) { + int64_t arrival_time_ms = TickTime::MillisecondTimestamp(); + if (packet_time.timestamp >= 0) + arrival_time_ms = (packet_time.timestamp + 500) / 1000; + size_t payload_size = length - header.headerLength; + remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size, + header, false); + } + + return channel_proxy_->ReceivedRTPPacket(packet, length, packet_time); +} + VoiceEngine* AudioReceiveStream::voice_engine() const { internal::AudioState* audio_state = static_cast(audio_state_.get()); diff --git a/webrtc/audio/audio_receive_stream.h b/webrtc/audio/audio_receive_stream.h index 37117427a1..d99956c2dd 100644 --- a/webrtc/audio/audio_receive_stream.h +++ b/webrtc/audio/audio_receive_stream.h @@ -36,20 +36,17 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream { const rtc::scoped_refptr& audio_state); ~AudioReceiveStream() override; - // webrtc::ReceiveStream implementation. + // webrtc::AudioReceiveStream implementation. void Start() override; void Stop() override; - void SignalNetworkState(NetworkState state) override; - bool DeliverRtcp(const uint8_t* packet, size_t length) override; - bool DeliverRtp(const uint8_t* packet, - size_t length, - const PacketTime& packet_time) override; - - // webrtc::AudioReceiveStream implementation. webrtc::AudioReceiveStream::Stats GetStats() const override; - void SetSink(std::unique_ptr sink) override; + void SignalNetworkState(NetworkState state); + bool DeliverRtcp(const uint8_t* packet, size_t length); + bool DeliverRtp(const uint8_t* packet, + size_t length, + const PacketTime& packet_time); const webrtc::AudioReceiveStream::Config& config() const; private: diff --git a/webrtc/audio/audio_send_stream.cc b/webrtc/audio/audio_send_stream.cc index c5dfd77836..c0a709e3c6 100644 --- a/webrtc/audio/audio_send_stream.cc +++ b/webrtc/audio/audio_send_stream.cc @@ -116,18 +116,6 @@ void AudioSendStream::Stop() { } } -void AudioSendStream::SignalNetworkState(NetworkState state) { - RTC_DCHECK(thread_checker_.CalledOnValidThread()); -} - -bool 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(!thread_checker_.CalledOnValidThread()); - return channel_proxy_->ReceivedRTCPPacket(packet, length); -} - bool AudioSendStream::SendTelephoneEvent(int payload_type, int event, int duration_ms) { RTC_DCHECK(thread_checker_.CalledOnValidThread()); @@ -218,6 +206,18 @@ webrtc::AudioSendStream::Stats AudioSendStream::GetStats() const { return stats; } +void AudioSendStream::SignalNetworkState(NetworkState state) { + RTC_DCHECK(thread_checker_.CalledOnValidThread()); +} + +bool 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(!thread_checker_.CalledOnValidThread()); + return channel_proxy_->ReceivedRTCPPacket(packet, length); +} + const webrtc::AudioSendStream::Config& AudioSendStream::config() const { RTC_DCHECK(thread_checker_.CalledOnValidThread()); return config_; diff --git a/webrtc/audio/audio_send_stream.h b/webrtc/audio/audio_send_stream.h index 183ad88189..61dd7f24b4 100644 --- a/webrtc/audio/audio_send_stream.h +++ b/webrtc/audio/audio_send_stream.h @@ -34,17 +34,15 @@ class AudioSendStream final : public webrtc::AudioSendStream { CongestionController* congestion_controller); ~AudioSendStream() override; - // webrtc::SendStream implementation. + // webrtc::AudioSendStream implementation. void Start() override; void Stop() override; - void SignalNetworkState(NetworkState state) override; - bool DeliverRtcp(const uint8_t* packet, size_t length) override; - - // webrtc::AudioSendStream implementation. bool SendTelephoneEvent(int payload_type, int event, int duration_ms) override; webrtc::AudioSendStream::Stats GetStats() const override; + void SignalNetworkState(NetworkState state); + bool DeliverRtcp(const uint8_t* packet, size_t length); const webrtc::AudioSendStream::Config& config() const; private: diff --git a/webrtc/audio_receive_stream.h b/webrtc/audio_receive_stream.h index 97feccc938..6d72b4d318 100644 --- a/webrtc/audio_receive_stream.h +++ b/webrtc/audio_receive_stream.h @@ -16,8 +16,8 @@ #include #include +#include "webrtc/common_types.h" #include "webrtc/config.h" -#include "webrtc/stream.h" #include "webrtc/transport.h" #include "webrtc/typedefs.h" @@ -31,7 +31,7 @@ class AudioSinkInterface; // of WebRtc/Libjingle. Please use the VoiceEngine API instead. // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4690 -class AudioReceiveStream : public ReceiveStream { +class AudioReceiveStream { public: struct Stats { uint32_t remote_ssrc = 0; @@ -103,6 +103,13 @@ class AudioReceiveStream : public ReceiveStream { std::map decoder_map; }; + // Starts stream activity. + // When a stream is active, it can receive, process and deliver packets. + virtual void Start() = 0; + // Stops stream activity. + // When a stream is stopped, it can't receive, process or deliver packets. + virtual void Stop() = 0; + virtual Stats GetStats() const = 0; // Sets an audio sink that receives unmixed audio from the receive stream. @@ -114,6 +121,9 @@ class AudioReceiveStream : public ReceiveStream { // is being pulled+rendered and/or if audio is being pulled for the purposes // of feeding to the AEC. virtual void SetSink(std::unique_ptr sink) = 0; + + protected: + virtual ~AudioReceiveStream() {} }; } // namespace webrtc diff --git a/webrtc/audio_send_stream.h b/webrtc/audio_send_stream.h index 18e71253f1..d5d16f2711 100644 --- a/webrtc/audio_send_stream.h +++ b/webrtc/audio_send_stream.h @@ -18,7 +18,6 @@ #include "webrtc/base/scoped_ptr.h" #include "webrtc/config.h" #include "webrtc/modules/audio_coding/codecs/audio_encoder.h" -#include "webrtc/stream.h" #include "webrtc/transport.h" #include "webrtc/typedefs.h" @@ -29,7 +28,7 @@ namespace webrtc { // of WebRtc/Libjingle. Please use the VoiceEngine API instead. // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4690 -class AudioSendStream : public SendStream { +class AudioSendStream { public: struct Stats { // TODO(solenberg): Harmonize naming and defaults with receive stream stats. @@ -90,10 +89,20 @@ class AudioSendStream : public SendStream { int red_payload_type = -1; // pt, or -1 to disable REDundant coding. }; + // Starts stream activity. + // When a stream is active, it can receive, process and deliver packets. + virtual void Start() = 0; + // Stops stream activity. + // When a stream is stopped, it can't receive, process or deliver packets. + virtual void Stop() = 0; + // TODO(solenberg): Make payload_type a config property instead. virtual bool SendTelephoneEvent(int payload_type, int event, int duration_ms) = 0; virtual Stats GetStats() const = 0; + + protected: + virtual ~AudioSendStream() {} }; } // namespace webrtc diff --git a/webrtc/common_types.h b/webrtc/common_types.h index e171e1bd8a..58aebdcdac 100644 --- a/webrtc/common_types.h +++ b/webrtc/common_types.h @@ -880,6 +880,11 @@ class StreamDataCountersCallback { // RTCP mode is described by RFC 5506. enum class RtcpMode { kOff, kCompound, kReducedSize }; +enum NetworkState { + kNetworkUp, + kNetworkDown, +}; + } // namespace webrtc #endif // WEBRTC_COMMON_TYPES_H_ diff --git a/webrtc/media/engine/fakewebrtccall.cc b/webrtc/media/engine/fakewebrtccall.cc index bc580e3ccc..e9edf27bcb 100644 --- a/webrtc/media/engine/fakewebrtccall.cc +++ b/webrtc/media/engine/fakewebrtccall.cc @@ -80,10 +80,6 @@ bool FakeAudioReceiveStream::DeliverRtp(const uint8_t* packet, return true; } -bool FakeAudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { - return true; -} - webrtc::AudioReceiveStream::Stats FakeAudioReceiveStream::GetStats() const { return stats_; } diff --git a/webrtc/media/engine/fakewebrtccall.h b/webrtc/media/engine/fakewebrtccall.h index 63c3b41fd4..c9caf8e158 100644 --- a/webrtc/media/engine/fakewebrtccall.h +++ b/webrtc/media/engine/fakewebrtccall.h @@ -48,15 +48,10 @@ class FakeAudioSendStream final : public webrtc::AudioSendStream { bool IsSending() const { return sending_; } private: - // webrtc::SendStream implementation. + // webrtc::AudioSendStream implementation. void Start() override { sending_ = true; } void Stop() override { sending_ = false; } - void SignalNetworkState(webrtc::NetworkState state) override {} - bool DeliverRtcp(const uint8_t* packet, size_t length) override { - return true; - } - // webrtc::AudioSendStream implementation. bool SendTelephoneEvent(int payload_type, int event, int duration_ms) override; webrtc::AudioSendStream::Stats GetStats() const override; @@ -77,18 +72,15 @@ class FakeAudioReceiveStream final : public webrtc::AudioReceiveStream { int received_packets() const { return received_packets_; } bool VerifyLastPacket(const uint8_t* data, size_t length) const; const webrtc::AudioSinkInterface* sink() const { return sink_.get(); } - bool DeliverRtp(const uint8_t* packet, size_t length, - const webrtc::PacketTime& packet_time) override; - bool DeliverRtcp(const uint8_t* packet, size_t length) override; + const webrtc::PacketTime& packet_time); + private: - // webrtc::ReceiveStream implementation. + // webrtc::AudioReceiveStream implementation. void Start() override {} void Stop() override {} - void SignalNetworkState(webrtc::NetworkState state) override {} - // webrtc::AudioReceiveStream implementation. webrtc::AudioReceiveStream::Stats GetStats() const override; void SetSink(std::unique_ptr sink) override; @@ -124,15 +116,9 @@ class FakeVideoSendStream final : public webrtc::VideoSendStream, private: void IncomingCapturedFrame(const webrtc::VideoFrame& frame) override; - // webrtc::SendStream implementation. + // webrtc::VideoSendStream implementation. void Start() override; void Stop() override; - void SignalNetworkState(webrtc::NetworkState state) override {} - bool DeliverRtcp(const uint8_t* packet, size_t length) override { - return true; - } - - // webrtc::VideoSendStream implementation. webrtc::VideoSendStream::Stats GetStats() override; void ReconfigureVideoEncoder( const webrtc::VideoEncoderConfig& config) override; @@ -166,20 +152,10 @@ class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream { void SetStats(const webrtc::VideoReceiveStream::Stats& stats); private: - // webrtc::ReceiveStream implementation. + // webrtc::VideoReceiveStream implementation. void Start() override; void Stop() override; - void SignalNetworkState(webrtc::NetworkState state) override {} - bool DeliverRtcp(const uint8_t* packet, size_t length) override { - return true; - } - bool DeliverRtp(const uint8_t* packet, - size_t length, - const webrtc::PacketTime& packet_time) override { - return true; - } - // webrtc::VideoReceiveStream implementation. webrtc::VideoReceiveStream::Stats GetStats() const override; webrtc::VideoReceiveStream::Config config_; diff --git a/webrtc/modules/congestion_controller/include/congestion_controller.h b/webrtc/modules/congestion_controller/include/congestion_controller.h index 7f18150065..284070cc21 100644 --- a/webrtc/modules/congestion_controller/include/congestion_controller.h +++ b/webrtc/modules/congestion_controller/include/congestion_controller.h @@ -15,12 +15,12 @@ #include "webrtc/base/constructormagic.h" #include "webrtc/base/scoped_ptr.h" +#include "webrtc/common_types.h" #include "webrtc/modules/include/module.h" #include "webrtc/modules/include/module_common_types.h" #include "webrtc/modules/pacing/packet_router.h" #include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h" #include "webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h" -#include "webrtc/stream.h" namespace rtc { struct SentPacket; diff --git a/webrtc/stream.h b/webrtc/stream.h deleted file mode 100644 index 5afab0f200..0000000000 --- a/webrtc/stream.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ -#ifndef WEBRTC_STREAM_H_ -#define WEBRTC_STREAM_H_ - -#include "webrtc/common_types.h" - -namespace webrtc { - -enum NetworkState { - kNetworkUp, - kNetworkDown, -}; - -// Common base class for streams. -class Stream { - public: - // Starts stream activity. - // When a stream is active, it can receive, process and deliver packets. - virtual void Start() = 0; - // Stops stream activity. - // When a stream is stopped, it can't receive, process or deliver packets. - virtual void Stop() = 0; - // Called to notify that network state has changed, so that the stream can - // respond, e.g. by pausing or resuming activity. - virtual void SignalNetworkState(NetworkState state) = 0; - // Called when a RTCP packet is received. - virtual bool DeliverRtcp(const uint8_t* packet, size_t length) = 0; - - protected: - virtual ~Stream() {} -}; - -// Common base class for receive streams. -class ReceiveStream : public Stream { - public: - // Called when a RTP packet is received. - virtual bool DeliverRtp(const uint8_t* packet, - size_t length, - const PacketTime& packet_time) = 0; -}; - -// Common base class for send streams. -// A tag class that denotes send stream type. -class SendStream : public Stream {}; - -} // namespace webrtc - -#endif // WEBRTC_STREAM_H_ diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc index b82fa9a670..814928b851 100644 --- a/webrtc/video/video_receive_stream.cc +++ b/webrtc/video/video_receive_stream.cc @@ -322,6 +322,22 @@ VideoReceiveStream::~VideoReceiveStream() { ->RemoveStream(rtp_stream_receiver_.GetRemoteSsrc()); } +void VideoReceiveStream::SignalNetworkState(NetworkState state) { + rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode + : RtcpMode::kOff); +} + + +bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { + return rtp_stream_receiver_.DeliverRtcp(packet, length); +} + +bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, + size_t length, + const PacketTime& packet_time) { + return rtp_stream_receiver_.DeliverRtp(packet, length, packet_time); +} + void VideoReceiveStream::Start() { if (decode_thread_.IsRunning()) return; @@ -358,16 +374,6 @@ VideoReceiveStream::Stats VideoReceiveStream::GetStats() const { return stats_proxy_.GetStats(); } -bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { - return rtp_stream_receiver_.DeliverRtcp(packet, length); -} - -bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, - size_t length, - const PacketTime& packet_time) { - return rtp_stream_receiver_.DeliverRtp(packet, length, packet_time); -} - void VideoReceiveStream::FrameCallback(VideoFrame* video_frame) { stats_proxy_.OnDecodedFrame(); @@ -421,11 +427,6 @@ int32_t VideoReceiveStream::Encoded( return 0; } -void VideoReceiveStream::SignalNetworkState(NetworkState state) { - rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode - : RtcpMode::kOff); -} - bool VideoReceiveStream::DecodeThreadFunction(void* ptr) { static_cast(ptr)->Decode(); return true; diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index a7ee42d01b..fa02d7c4c1 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -54,16 +54,16 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, VieRemb* remb); ~VideoReceiveStream() override; - // webrtc::ReceiveStream implementation. - void Start() override; - void Stop() override; - void SignalNetworkState(NetworkState state) override; - bool DeliverRtcp(const uint8_t* packet, size_t length) override; + void SignalNetworkState(NetworkState state); + bool DeliverRtcp(const uint8_t* packet, size_t length); bool DeliverRtp(const uint8_t* packet, size_t length, - const PacketTime& packet_time) override; + const PacketTime& packet_time); // webrtc::VideoReceiveStream implementation. + void Start() override; + void Stop() override; + webrtc::VideoReceiveStream::Stats GetStats() const override; // Overrides I420FrameCallback. diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc index 40871af121..cecc7e9b39 100644 --- a/webrtc/video/video_send_stream.cc +++ b/webrtc/video/video_send_stream.cc @@ -491,8 +491,25 @@ VideoSendStream::~VideoSendStream() { } } -VideoCaptureInput* VideoSendStream::Input() { - return &input_; +void VideoSendStream::SignalNetworkState(NetworkState state) { + // When network goes up, enable RTCP status before setting transmission state. + // When it goes down, disable RTCP afterwards. This ensures that any packets + // sent due to the network state changed will not be dropped. + if (state == kNetworkUp) { + for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) + rtp_rtcp->SetRTCPStatus(config_.rtp.rtcp_mode); + } + vie_encoder_.SetNetworkTransmissionState(state == kNetworkUp); + if (state == kNetworkDown) { + for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) + rtp_rtcp->SetRTCPStatus(RtcpMode::kOff); + } +} + +bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { + for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) + rtp_rtcp->IncomingRtcpPacket(packet, length); + return true; } void VideoSendStream::Start() { @@ -514,6 +531,10 @@ void VideoSendStream::Stop() { payload_router_.set_active(false); } +VideoCaptureInput* VideoSendStream::Input() { + return &input_; +} + bool VideoSendStream::EncoderThreadFunction(void* obj) { static_cast(obj)->EncoderProcess(); // We're done, return false to abort. @@ -580,12 +601,6 @@ void VideoSendStream::ReconfigureVideoEncoder( encoder_wakeup_event_.Set(); } -bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->IncomingRtcpPacket(packet, length); - return true; -} - VideoSendStream::Stats VideoSendStream::GetStats() { return stats_proxy_.GetStats(); } @@ -714,21 +729,6 @@ std::map VideoSendStream::GetRtpStates() const { return rtp_states; } -void VideoSendStream::SignalNetworkState(NetworkState state) { - // When network goes up, enable RTCP status before setting transmission state. - // When it goes down, disable RTCP afterwards. This ensures that any packets - // sent due to the network state changed will not be dropped. - if (state == kNetworkUp) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetRTCPStatus(config_.rtp.rtcp_mode); - } - vie_encoder_.SetNetworkTransmissionState(state == kNetworkUp); - if (state == kNetworkDown) { - for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) - rtp_rtcp->SetRTCPStatus(RtcpMode::kOff); - } -} - int VideoSendStream::GetPaddingNeededBps() const { return vie_encoder_.GetPaddingNeededBps(); } diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h index 475b58e56a..fb16b67aaa 100644 --- a/webrtc/video/video_send_stream.h +++ b/webrtc/video/video_send_stream.h @@ -63,13 +63,12 @@ class VideoSendStream : public webrtc::VideoSendStream, ~VideoSendStream() override; - // webrtc::SendStream implementation. - void Start() override; - void Stop() override; - void SignalNetworkState(NetworkState state) override; - bool DeliverRtcp(const uint8_t* packet, size_t length) override; + void SignalNetworkState(NetworkState state); + bool DeliverRtcp(const uint8_t* packet, size_t length); // webrtc::VideoSendStream implementation. + void Start() override; + void Stop() override; VideoCaptureInput* Input() override; void ReconfigureVideoEncoder(const VideoEncoderConfig& config) override; Stats GetStats() override; diff --git a/webrtc/video_receive_stream.h b/webrtc/video_receive_stream.h index 1b46c17749..167df47dff 100644 --- a/webrtc/video_receive_stream.h +++ b/webrtc/video_receive_stream.h @@ -20,14 +20,13 @@ #include "webrtc/common_video/include/frame_callback.h" #include "webrtc/config.h" #include "webrtc/media/base/videosinkinterface.h" -#include "webrtc/stream.h" #include "webrtc/transport.h" namespace webrtc { class VideoDecoder; -class VideoReceiveStream : public ReceiveStream { +class VideoReceiveStream { public: // TODO(mflodman) Move all these settings to VideoDecoder and move the // declaration to common_types.h. @@ -176,8 +175,18 @@ class VideoReceiveStream : public ReceiveStream { int target_delay_ms = 0; }; + // Starts stream activity. + // When a stream is active, it can receive, process and deliver packets. + virtual void Start() = 0; + // Stops stream activity. + // When a stream is stopped, it can't receive, process or deliver packets. + virtual void Stop() = 0; + // TODO(pbos): Add info on currently-received codec to Stats. virtual Stats GetStats() const = 0; + + protected: + virtual ~VideoReceiveStream() {} }; } // namespace webrtc diff --git a/webrtc/video_send_stream.h b/webrtc/video_send_stream.h index 50a8df3f0d..886367f0a5 100644 --- a/webrtc/video_send_stream.h +++ b/webrtc/video_send_stream.h @@ -18,7 +18,6 @@ #include "webrtc/common_video/include/frame_callback.h" #include "webrtc/config.h" #include "webrtc/media/base/videosinkinterface.h" -#include "webrtc/stream.h" #include "webrtc/transport.h" #include "webrtc/media/base/videosinkinterface.h" @@ -39,7 +38,7 @@ class VideoCaptureInput { virtual ~VideoCaptureInput() {} }; -class VideoSendStream : public SendStream { +class VideoSendStream { public: struct StreamStats { FrameCounts frame_counts; @@ -167,6 +166,13 @@ class VideoSendStream : public SendStream { bool suspend_below_min_bitrate = false; }; + // Starts stream activity. + // When a stream is active, it can receive, process and deliver packets. + virtual void Start() = 0; + // Stops stream activity. + // When a stream is stopped, it can't receive, process or deliver packets. + virtual void Stop() = 0; + // Gets interface used to insert captured frames. Valid as long as the // VideoSendStream is valid. virtual VideoCaptureInput* Input() = 0; @@ -177,6 +183,9 @@ class VideoSendStream : public SendStream { virtual void ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0; virtual Stats GetStats() = 0; + + protected: + virtual ~VideoSendStream() {} }; } // namespace webrtc diff --git a/webrtc/webrtc.gyp b/webrtc/webrtc.gyp index abc48e981e..21387448ef 100644 --- a/webrtc/webrtc.gyp +++ b/webrtc/webrtc.gyp @@ -126,7 +126,6 @@ 'audio_state.h', 'call.h', 'config.h', - 'stream.h', 'transport.h', 'video_receive_stream.h', 'video_send_stream.h',