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

@@ -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

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<FakeVideoSendStream*>& GetVideoSendStreams();
@@ -133,7 +159,7 @@ class FakeCall : public webrtc::Call, public webrtc::PacketReceiver {
   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 @@ 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<FakeVideoSendStream*> video_send_streams_;
   std::vector<FakeVideoReceiveStream*> video_receive_streams_;

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) {

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) {

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 @@ class AudioReceiveStream {
   };
 
   virtual Stats GetStats() const = 0;
-
- protected:
-  virtual ~AudioReceiveStream() {}
 };
 }  // namespace webrtc
 

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
 

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_

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_

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;
 }

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_;

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<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 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
     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 @@ 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();

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);
 }
 

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:

webrtc/video/video_send_stream.cc

@@ -436,14 +436,14 @@ std::map<uint32_t, RtpState> 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);
 }
 

webrtc/video/video_send_stream.h

@@ -47,24 +47,22 @@ class VideoSendStream : public webrtc::VideoSendStream {
                   const VideoEncoderConfig& encoder_config,
                   const std::map<uint32_t, RtpState>& 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<uint32_t, RtpState> RtpStateMap;
   RtpStateMap GetRtpStates() const;
 
-  void SignalNetworkState(Call::NetworkState state);
-
   int64_t GetRtt() const;
 
  private:

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

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

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',