From cd6702282a49448adda470934f4bd9e6181cab22 Mon Sep 17 00:00:00 2001 From: Jelena Marusic Date: Thu, 16 Jul 2015 09:30:09 +0200 Subject: [PATCH] Define Stream base classes BUG=webrtc:4690 Defined classes Stream, SendStream and ReceiveStream. Inherited existing stream classes from either SendStream or ReceiveStream. This is a step towards having a Transport associated with streams instead of a Call. It will allow a lot of code in the Call to be media type agnostic. R=henrika@webrtc.org, pbos@webrtc.org, stefan@webrtc.org Review URL: https://codereview.webrtc.org/1226123005 . Cr-Commit-Position: refs/heads/master@{#9591} --- talk/media/webrtc/fakewebrtccall.cc | 6 +-- talk/media/webrtc/fakewebrtccall.h | 50 ++++++++++++----- talk/media/webrtc/webrtcvideoengine2.cc | 3 +- .../webrtc/webrtcvideoengine2_unittest.cc | 6 +-- webrtc/audio_receive_stream.h | 6 +-- webrtc/audio_send_stream.h | 6 +-- webrtc/call.h | 5 +- webrtc/stream.h | 54 +++++++++++++++++++ webrtc/video/audio_receive_stream.cc | 9 ++++ webrtc/video/audio_receive_stream.h | 11 ++-- webrtc/video/end_to_end_tests.cc | 22 ++++---- webrtc/video/video_receive_stream.cc | 6 +-- webrtc/video/video_receive_stream.h | 15 +++--- webrtc/video/video_send_stream.cc | 8 +-- webrtc/video/video_send_stream.h | 14 +++-- webrtc/video_receive_stream.h | 9 +--- webrtc/video_send_stream.h | 9 +--- webrtc/webrtc.gyp | 5 +- 18 files changed, 160 insertions(+), 84 deletions(-) create mode 100644 webrtc/stream.h diff --git a/talk/media/webrtc/fakewebrtccall.cc b/talk/media/webrtc/fakewebrtccall.cc index cfb6bd1b11..03f7763bb2 100644 --- a/talk/media/webrtc/fakewebrtccall.cc +++ b/talk/media/webrtc/fakewebrtccall.cc @@ -195,7 +195,7 @@ void FakeVideoReceiveStream::SetStats( FakeCall::FakeCall(const webrtc::Call::Config& config) : config_(config), - network_state_(kNetworkUp), + network_state_(webrtc::kNetworkUp), num_created_send_streams_(0), num_created_receive_streams_(0) { } @@ -231,7 +231,7 @@ const FakeAudioReceiveStream* FakeCall::GetAudioReceiveStream(uint32_t ssrc) { return nullptr; } -webrtc::Call::NetworkState FakeCall::GetNetworkState() const { +webrtc::NetworkState FakeCall::GetNetworkState() const { return network_state_; } @@ -357,7 +357,7 @@ void FakeCall::SetBitrateConfig( config_.bitrate_config = bitrate_config; } -void FakeCall::SignalNetworkState(webrtc::Call::NetworkState state) { +void FakeCall::SignalNetworkState(webrtc::NetworkState state) { network_state_ = state; } } // namespace cricket diff --git a/talk/media/webrtc/fakewebrtccall.h b/talk/media/webrtc/fakewebrtccall.h index c500416d34..dd7772d222 100644 --- a/talk/media/webrtc/fakewebrtccall.h +++ b/talk/media/webrtc/fakewebrtccall.h @@ -42,6 +42,7 @@ class FakeAudioReceiveStream : public webrtc::AudioReceiveStream { explicit FakeAudioReceiveStream( const webrtc::AudioReceiveStream::Config& config); + // webrtc::AudioReceiveStream implementation. webrtc::AudioReceiveStream::Stats GetStats() const override; const webrtc::AudioReceiveStream::Config& GetConfig() const; @@ -50,6 +51,17 @@ class FakeAudioReceiveStream : public webrtc::AudioReceiveStream { void IncrementReceivedPackets(); private: + // webrtc::ReceiveStream 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) override { + return true; + } + webrtc::AudioReceiveStream::Config config_; int received_packets_; }; @@ -74,15 +86,20 @@ class FakeVideoSendStream : public webrtc::VideoSendStream, private: void IncomingCapturedFrame(const webrtc::VideoFrame& frame) override; - webrtc::VideoSendStream::Stats GetStats() override; - - bool ReconfigureVideoEncoder( - const webrtc::VideoEncoderConfig& config) override; - - webrtc::VideoCaptureInput* Input() override; + // webrtc::SendStream 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; + bool ReconfigureVideoEncoder( + const webrtc::VideoEncoderConfig& config) override; + webrtc::VideoCaptureInput* Input() override; bool sending_; webrtc::VideoSendStream::Config config_; @@ -111,10 +128,19 @@ class FakeVideoReceiveStream : public webrtc::VideoReceiveStream { void SetStats(const webrtc::VideoReceiveStream::Stats& stats); private: - webrtc::VideoReceiveStream::Stats GetStats() const override; - + // webrtc::ReceiveStream 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) override { + return true; + } + + // webrtc::VideoReceiveStream implementation. + webrtc::VideoReceiveStream::Stats GetStats() const override; webrtc::VideoReceiveStream::Config config_; bool receiving_; @@ -124,7 +150,7 @@ class FakeVideoReceiveStream : public webrtc::VideoReceiveStream { class FakeCall : public webrtc::Call, public webrtc::PacketReceiver { public: explicit FakeCall(const webrtc::Call::Config& config); - ~FakeCall(); + ~FakeCall() override; webrtc::Call::Config GetConfig() const; const std::vector& GetVideoSendStreams(); @@ -133,7 +159,7 @@ class FakeCall : public webrtc::Call, public webrtc::PacketReceiver { const std::vector& GetAudioReceiveStreams(); const FakeAudioReceiveStream* GetAudioReceiveStream(uint32_t ssrc); - webrtc::Call::NetworkState GetNetworkState() const; + webrtc::NetworkState GetNetworkState() const; int GetNumCreatedSendStreams() const; int GetNumCreatedReceiveStreams() const; void SetStats(const webrtc::Call::Stats& stats); @@ -166,10 +192,10 @@ class FakeCall : public webrtc::Call, public webrtc::PacketReceiver { void SetBitrateConfig( const webrtc::Call::Config::BitrateConfig& bitrate_config) override; - void SignalNetworkState(webrtc::Call::NetworkState state) override; + void SignalNetworkState(webrtc::NetworkState state) override; webrtc::Call::Config config_; - webrtc::Call::NetworkState network_state_; + webrtc::NetworkState network_state_; webrtc::Call::Stats stats_; std::vector video_send_streams_; std::vector video_receive_streams_; diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc index 657475b281..91997954d6 100644 --- a/talk/media/webrtc/webrtcvideoengine2.cc +++ b/talk/media/webrtc/webrtcvideoengine2.cc @@ -1421,8 +1421,7 @@ void WebRtcVideoChannel2::OnRtcpReceived( void WebRtcVideoChannel2::OnReadyToSend(bool ready) { LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready."); - call_->SignalNetworkState(ready ? webrtc::Call::kNetworkUp - : webrtc::Call::kNetworkDown); + call_->SignalNetworkState(ready ? webrtc::kNetworkUp : webrtc::kNetworkDown); } bool WebRtcVideoChannel2::MuteStream(uint32 ssrc, bool mute) { diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.cc b/talk/media/webrtc/webrtcvideoengine2_unittest.cc index f3d3a542ab..745a0c4ade 100644 --- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc +++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc @@ -2170,13 +2170,13 @@ TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) { } TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) { - EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState()); + EXPECT_EQ(webrtc::kNetworkUp, fake_call_->GetNetworkState()); channel_->OnReadyToSend(false); - EXPECT_EQ(webrtc::Call::kNetworkDown, fake_call_->GetNetworkState()); + EXPECT_EQ(webrtc::kNetworkDown, fake_call_->GetNetworkState()); channel_->OnReadyToSend(true); - EXPECT_EQ(webrtc::Call::kNetworkUp, fake_call_->GetNetworkState()); + EXPECT_EQ(webrtc::kNetworkUp, fake_call_->GetNetworkState()); } TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) { diff --git a/webrtc/audio_receive_stream.h b/webrtc/audio_receive_stream.h index 5e200785a9..44e232c34c 100644 --- a/webrtc/audio_receive_stream.h +++ b/webrtc/audio_receive_stream.h @@ -16,13 +16,14 @@ #include #include "webrtc/config.h" +#include "webrtc/stream.h" #include "webrtc/typedefs.h" namespace webrtc { class AudioDecoder; -class AudioReceiveStream { +class AudioReceiveStream : public ReceiveStream { public: struct Stats {}; @@ -61,9 +62,6 @@ class AudioReceiveStream { }; virtual Stats GetStats() const = 0; - - protected: - virtual ~AudioReceiveStream() {} }; } // namespace webrtc diff --git a/webrtc/audio_send_stream.h b/webrtc/audio_send_stream.h index 4ad15d6836..9ac78da06d 100644 --- a/webrtc/audio_send_stream.h +++ b/webrtc/audio_send_stream.h @@ -17,11 +17,12 @@ #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/typedefs.h" namespace webrtc { -class AudioSendStream { +class AudioSendStream : public SendStream { public: struct Stats {}; @@ -45,9 +46,6 @@ class AudioSendStream { }; virtual Stats GetStats() const = 0; - - protected: - virtual ~AudioSendStream() {} }; } // namespace webrtc diff --git a/webrtc/call.h b/webrtc/call.h index d1a45c8bab..b94029db47 100644 --- a/webrtc/call.h +++ b/webrtc/call.h @@ -68,10 +68,6 @@ class LoadObserver { // etc. class Call { public: - enum NetworkState { - kNetworkUp, - kNetworkDown, - }; struct Config { Config() = delete; explicit Config(newapi::Transport* send_transport) @@ -153,6 +149,7 @@ class Call { virtual ~Call() {} }; + } // namespace webrtc #endif // WEBRTC_CALL_H_ diff --git a/webrtc/stream.h b/webrtc/stream.h new file mode 100644 index 0000000000..fd30571726 --- /dev/null +++ b/webrtc/stream.h @@ -0,0 +1,54 @@ +/* + * 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) = 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/audio_receive_stream.cc b/webrtc/video/audio_receive_stream.cc index ef0eb783e2..88fd431f82 100644 --- a/webrtc/video/audio_receive_stream.cc +++ b/webrtc/video/audio_receive_stream.cc @@ -71,6 +71,15 @@ webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats() const { return webrtc::AudioReceiveStream::Stats(); } +void AudioReceiveStream::Start() { +} + +void AudioReceiveStream::Stop() { +} + +void AudioReceiveStream::SignalNetworkState(NetworkState state) { +} + bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { return false; } diff --git a/webrtc/video/audio_receive_stream.h b/webrtc/video/audio_receive_stream.h index 9935117d0f..08d929adb3 100644 --- a/webrtc/video/audio_receive_stream.h +++ b/webrtc/video/audio_receive_stream.h @@ -26,10 +26,15 @@ class AudioReceiveStream : public webrtc::AudioReceiveStream { const webrtc::AudioReceiveStream::Config& config); ~AudioReceiveStream() override {} - webrtc::AudioReceiveStream::Stats GetStats() const 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; + bool DeliverRtp(const uint8_t* packet, size_t length) override; - bool DeliverRtcp(const uint8_t* packet, size_t length); - bool DeliverRtp(const uint8_t* packet, size_t length); + // webrtc::AudioReceiveStream implementation. + webrtc::AudioReceiveStream::Stats GetStats() const override; const webrtc::AudioReceiveStream::Config& config() const { return config_; diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc index 82fbe3ae52..ab4dfaf65a 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -2509,7 +2509,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) { FakeEncoder(Clock::GetRealTimeClock()), encoded_frames_(EventWrapper::Create()), packet_event_(EventWrapper::Create()), - sender_state_(Call::kNetworkUp), + sender_state_(kNetworkUp), sender_rtp_(0), sender_rtcp_(0), receiver_rtcp_(0), @@ -2559,17 +2559,17 @@ TEST_F(EndToEndTest, RespectsNetworkState) { WaitForPacketsOrSilence(false, false); // Sender-side network down. - sender_call_->SignalNetworkState(Call::kNetworkDown); + sender_call_->SignalNetworkState(kNetworkDown); { rtc::CritScope lock(&test_crit_); // After network goes down we shouldn't be encoding more frames. - sender_state_ = Call::kNetworkDown; + sender_state_ = kNetworkDown; } // Wait for receiver-packets and no sender packets. WaitForPacketsOrSilence(true, false); // Receiver-side network down. - receiver_call_->SignalNetworkState(Call::kNetworkDown); + receiver_call_->SignalNetworkState(kNetworkDown); WaitForPacketsOrSilence(true, true); // Network back up again for both. @@ -2577,10 +2577,10 @@ TEST_F(EndToEndTest, RespectsNetworkState) { rtc::CritScope lock(&test_crit_); // It's OK to encode frames again, as we're about to bring up the // network. - sender_state_ = Call::kNetworkUp; + sender_state_ = kNetworkUp; } - sender_call_->SignalNetworkState(Call::kNetworkUp); - receiver_call_->SignalNetworkState(Call::kNetworkUp); + sender_call_->SignalNetworkState(kNetworkUp); + receiver_call_->SignalNetworkState(kNetworkUp); WaitForPacketsOrSilence(false, false); } @@ -2589,7 +2589,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) { const std::vector* frame_types) override { { rtc::CritScope lock(&test_crit_); - if (sender_state_ == Call::kNetworkDown) { + if (sender_state_ == kNetworkDown) { ++down_frames_; EXPECT_LE(down_frames_, 1) << "Encoding more than one frame while network is down."; @@ -2655,7 +2655,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) { const rtc::scoped_ptr packet_event_; Call* sender_call_; Call* receiver_call_; - Call::NetworkState sender_state_ GUARDED_BY(test_crit_); + NetworkState sender_state_ GUARDED_BY(test_crit_); int sender_rtp_ GUARDED_BY(test_crit_); int sender_rtcp_ GUARDED_BY(test_crit_); int receiver_rtcp_ GUARDED_BY(test_crit_); @@ -2720,7 +2720,7 @@ TEST_F(EndToEndTest, NewSendStreamsRespectNetworkDown) { UnusedTransport transport; CreateSenderCall(Call::Config(&transport)); - sender_call_->SignalNetworkState(Call::kNetworkDown); + sender_call_->SignalNetworkState(kNetworkDown); CreateSendConfig(1); UnusedEncoder unused_encoder; @@ -2742,7 +2742,7 @@ TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) { CreateReceiverCall(Call::Config(&transport)); sender_transport.SetReceiver(receiver_call_->Receiver()); - receiver_call_->SignalNetworkState(Call::kNetworkDown); + receiver_call_->SignalNetworkState(kNetworkDown); CreateSendConfig(1); CreateMatchingReceiveConfigs(); diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc index d7874fa0df..6d6619a38f 100644 --- a/webrtc/video/video_receive_stream.cc +++ b/webrtc/video/video_receive_stream.cc @@ -323,10 +323,10 @@ int VideoReceiveStream::RenderFrame(const uint32_t /*stream_id*/, return 0; } -void VideoReceiveStream::SignalNetworkState(Call::NetworkState state) { - if (state == Call::kNetworkUp) +void VideoReceiveStream::SignalNetworkState(NetworkState state) { + if (state == kNetworkUp) SetRtcpMode(config_.rtp.rtcp_mode); - if (state == Call::kNetworkDown) + if (state == kNetworkDown) vie_channel_->SetRTCPMode(kRtcpOff); } diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index af341a9b11..717622d0fa 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -44,11 +44,17 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, const VideoReceiveStream::Config& config, newapi::Transport* transport, webrtc::VoiceEngine* voice_engine); - virtual ~VideoReceiveStream(); + ~VideoReceiveStream() override; + // webrtc::ReceiveStream implementation. void Start() override; void Stop() override; - Stats GetStats() const 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) override; + + // webrtc::VideoReceiveStream implementation. + webrtc::VideoReceiveStream::Stats GetStats() const override; // Overrides I420FrameCallback. void FrameCallback(VideoFrame* video_frame) override; @@ -59,11 +65,6 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, const Config& config() const { return config_; } - void SignalNetworkState(Call::NetworkState state); - - bool DeliverRtcp(const uint8_t* packet, size_t length); - bool DeliverRtp(const uint8_t* packet, size_t length); - void SetSyncChannel(VoiceEngine* voice_engine, int audio_channel_id); private: diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc index 0b59c8bba2..c0d73490f8 100644 --- a/webrtc/video/video_send_stream.cc +++ b/webrtc/video/video_send_stream.cc @@ -436,14 +436,14 @@ std::map VideoSendStream::GetRtpStates() const { return rtp_states; } -void VideoSendStream::SignalNetworkState(Call::NetworkState state) { +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 == Call::kNetworkUp) + if (state == kNetworkUp) vie_channel_->SetRTCPMode(kRtcpCompound); - vie_encoder_->SetNetworkTransmissionState(state == Call::kNetworkUp); - if (state == Call::kNetworkDown) + vie_encoder_->SetNetworkTransmissionState(state == kNetworkUp); + if (state == kNetworkDown) vie_channel_->SetRTCPMode(kRtcpOff); } diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h index 84537dd2b5..b660dd0819 100644 --- a/webrtc/video/video_send_stream.h +++ b/webrtc/video/video_send_stream.h @@ -47,24 +47,22 @@ class VideoSendStream : public webrtc::VideoSendStream { const VideoEncoderConfig& encoder_config, const std::map& suspended_ssrcs); - virtual ~VideoSendStream(); - - VideoCaptureInput* Input() override; + ~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; + // webrtc::VideoSendStream implementation. + VideoCaptureInput* Input() override; bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) override; - Stats GetStats() override; - bool DeliverRtcp(const uint8_t* packet, size_t length); - typedef std::map RtpStateMap; RtpStateMap GetRtpStates() const; - void SignalNetworkState(Call::NetworkState state); - int64_t GetRtt() const; private: diff --git a/webrtc/video_receive_stream.h b/webrtc/video_receive_stream.h index 11033812d5..95253366d3 100644 --- a/webrtc/video_receive_stream.h +++ b/webrtc/video_receive_stream.h @@ -18,6 +18,7 @@ #include "webrtc/common_types.h" #include "webrtc/config.h" #include "webrtc/frame_callback.h" +#include "webrtc/stream.h" #include "webrtc/transport.h" #include "webrtc/video_renderer.h" @@ -31,7 +32,7 @@ enum RtcpMode { kRtcpCompound, kRtcpReducedSize }; class VideoDecoder; -class VideoReceiveStream { +class VideoReceiveStream : public ReceiveStream { public: // TODO(mflodman) Move all these settings to VideoDecoder and move the // declaration to common_types.h. @@ -165,14 +166,8 @@ class VideoReceiveStream { int target_delay_ms = 0; }; - virtual void Start() = 0; - 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 69df41c1d5..540f5be462 100644 --- a/webrtc/video_send_stream.h +++ b/webrtc/video_send_stream.h @@ -17,6 +17,7 @@ #include "webrtc/common_types.h" #include "webrtc/config.h" #include "webrtc/frame_callback.h" +#include "webrtc/stream.h" #include "webrtc/video_renderer.h" namespace webrtc { @@ -35,7 +36,7 @@ class VideoCaptureInput { virtual ~VideoCaptureInput() {} }; -class VideoSendStream { +class VideoSendStream : public SendStream { public: struct StreamStats { FrameCounts frame_counts; @@ -140,18 +141,12 @@ class VideoSendStream { // VideoSendStream is valid. virtual VideoCaptureInput* Input() = 0; - virtual void Start() = 0; - virtual void Stop() = 0; - // Set which streams to send. Must have at least as many SSRCs as configured // in the config. Encoder settings are passed on to the encoder instance along // with the VideoStream settings. virtual bool 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 b1574d22a6..1f0412e845 100644 --- a/webrtc/webrtc.gyp +++ b/webrtc/webrtc.gyp @@ -61,15 +61,16 @@ ], }, { - # TODO(pbos): This is intended to contain audio parts as well as soon as - # VoiceEngine moves to the same new API format. 'target_name': 'webrtc', 'type': 'static_library', 'sources': [ + 'audio_receive_stream.h', + 'audio_send_stream.h', 'call.h', 'config.h', 'experiments.h', 'frame_callback.h', + 'stream.h', 'transport.h', 'video_receive_stream.h', 'video_renderer.h',