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}
diff --git a/talk/media/webrtc/fakewebrtccall.cc b/talk/media/webrtc/fakewebrtccall.cc
index cfb6bd1..03f7763 100644
--- a/talk/media/webrtc/fakewebrtccall.cc
+++ b/talk/media/webrtc/fakewebrtccall.cc
@@ -195,7 +195,7 @@
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 @@
return nullptr;
}
-webrtc::Call::NetworkState FakeCall::GetNetworkState() const {
+webrtc::NetworkState FakeCall::GetNetworkState() const {
return network_state_;
}
@@ -357,7 +357,7 @@
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 c500416..dd7772d 100644
--- a/talk/media/webrtc/fakewebrtccall.h
+++ b/talk/media/webrtc/fakewebrtccall.h
@@ -42,6 +42,7 @@
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 @@
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 @@
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 @@
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 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<FakeVideoSendStream*>& GetVideoSendStreams();
@@ -133,7 +159,7 @@
const std::vector<FakeAudioReceiveStream*>& 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 @@
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<FakeVideoSendStream*> video_send_streams_;
std::vector<FakeVideoReceiveStream*> video_receive_streams_;
diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc
index 657475b..9199795 100644
--- a/talk/media/webrtc/webrtcvideoengine2.cc
+++ b/talk/media/webrtc/webrtcvideoengine2.cc
@@ -1421,8 +1421,7 @@
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 f3d3a54..745a0c4 100644
--- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc
+++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc
@@ -2170,13 +2170,13 @@
}
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 5e20078..44e232c 100644
--- a/webrtc/audio_receive_stream.h
+++ b/webrtc/audio_receive_stream.h
@@ -16,13 +16,14 @@
#include <vector>
#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 @@
};
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 4ad15d6..9ac78da 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 @@
};
virtual Stats GetStats() const = 0;
-
- protected:
- virtual ~AudioSendStream() {}
};
} // namespace webrtc
diff --git a/webrtc/call.h b/webrtc/call.h
index d1a45c8..b94029d 100644
--- a/webrtc/call.h
+++ b/webrtc/call.h
@@ -68,10 +68,6 @@
// etc.
class Call {
public:
- enum NetworkState {
- kNetworkUp,
- kNetworkDown,
- };
struct Config {
Config() = delete;
explicit Config(newapi::Transport* send_transport)
@@ -153,6 +149,7 @@
virtual ~Call() {}
};
+
} // namespace webrtc
#endif // WEBRTC_CALL_H_
diff --git a/webrtc/stream.h b/webrtc/stream.h
new file mode 100644
index 0000000..fd30571
--- /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 ef0eb78..88fd431 100644
--- a/webrtc/video/audio_receive_stream.cc
+++ b/webrtc/video/audio_receive_stream.cc
@@ -71,6 +71,15 @@
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 9935117..08d929a 100644
--- a/webrtc/video/audio_receive_stream.h
+++ b/webrtc/video/audio_receive_stream.h
@@ -26,10 +26,15 @@
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 82fbe3a..ab4dfaf 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -2509,7 +2509,7 @@
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 @@
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 @@
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 @@
const std::vector<VideoFrameType>* 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 @@
const rtc::scoped_ptr<EventWrapper> 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 @@
UnusedTransport transport;
CreateSenderCall(Call::Config(&transport));
- sender_call_->SignalNetworkState(Call::kNetworkDown);
+ sender_call_->SignalNetworkState(kNetworkDown);
CreateSendConfig(1);
UnusedEncoder unused_encoder;
@@ -2742,7 +2742,7 @@
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 d7874fa..6d6619a 100644
--- a/webrtc/video/video_receive_stream.cc
+++ b/webrtc/video/video_receive_stream.cc
@@ -323,10 +323,10 @@
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 af341a9..717622d 100644
--- a/webrtc/video/video_receive_stream.h
+++ b/webrtc/video/video_receive_stream.h
@@ -44,11 +44,17 @@
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 @@
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 0b59c8b..c0d7349 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -436,14 +436,14 @@
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 84537dd..b660dd0 100644
--- a/webrtc/video/video_send_stream.h
+++ b/webrtc/video/video_send_stream.h
@@ -47,24 +47,22 @@
const VideoEncoderConfig& encoder_config,
const std::map<uint32_t, RtpState>& suspended_ssrcs);
- virtual ~VideoSendStream();
+ ~VideoSendStream() override;
- VideoCaptureInput* Input() 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<uint32_t, RtpState> 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 1103381..9525336 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 @@
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 @@
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 69df41c..540f5be 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 @@
virtual ~VideoCaptureInput() {}
};
-class VideoSendStream {
+class VideoSendStream : public SendStream {
public:
struct StreamStats {
FrameCounts frame_counts;
@@ -140,18 +141,12 @@
// 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 b1574d2..1f0412e 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',
