Intel® Collaboration Suite for WebRTC  version 4.3.1
Open WebRTC Toolkit (OWT) Client SDK for Windows*
stream.h
1 // Copyright (C) <2018> Intel Corporation
2 //
3 // SPDX-License-Identifier: Apache-2.0
4 #ifndef OWT_BASE_STREAM_H_
5 #define OWT_BASE_STREAM_H_
6 #include <mutex>
7 #include <unordered_map>
8 #include <vector>
9 #include "owt/base/commontypes.h"
10 #include "owt/base/exception.h"
11 #include "owt/base/localcamerastreamparameters.h"
12 #include "owt/base/macros.h"
13 #include "owt/base/options.h"
14 #include "owt/base/videoencoderinterface.h"
15 #include "owt/base/videorendererinterface.h"
16 #include "owt/base/audioplayerinterface.h"
17 namespace webrtc {
18 class MediaStreamInterface;
19 class VideoTrackSourceInterface;
20 class MediaConstraints;
21 } // namespace webrtc
22 namespace owt {
23 namespace conference {
24 class ConferencePeerConnectionChannel;
25 class ConferenceClient;
26 class ConferenceInfo;
27 } // namespace conference
28 namespace p2p {
29 class P2PPeerConnectionChannel;
30 }
31 namespace base {
32 class MediaConstraintsImpl;
33 class CustomizedFramesCapturer;
34 class BasicDesktopCapturer;
35 class VideoFrameGeneratorInterface;
36 #if defined(WEBRTC_MAC)
37 class ObjcVideoCapturerInterface;
38 #endif
39 using webrtc::MediaStreamInterface;
42  public:
45  virtual void OnEnded() {}
47  virtual void OnUpdated() {}
49  virtual void OnMute(TrackKind track_kind) {}
51  virtual void OnUnmute(TrackKind track_kind) {}
52 };
53 class WebrtcVideoRendererImpl;
54 class WebrtcAudioRendererImpl;
55 #if defined(WEBRTC_WIN)
56 class WebrtcVideoRendererD3D9Impl;
57 #endif
58 class Stream {
60  public:
61  Stream(MediaStreamInterface* media_stream, StreamSourceInfo source);
63  MediaStreamInterface* MediaStream() const;
69  virtual std::string Id() const;
71  virtual void DisableAudio();
73  virtual void DisableVideo();
75  virtual void EnableAudio();
77  virtual void EnableVideo();
83  virtual const std::unordered_map<std::string, std::string> Attributes()
84  const {
85  return attributes_;
86  }
93  virtual StreamSourceInfo Source() const;
94 #if defined(WEBRTC_WIN) || defined(WEBRTC_LINUX)
95  virtual void AttachVideoRenderer(VideoRendererInterface& renderer);
101  virtual void AttachVideoRenderer(VideoRenderWindow& render_window);
104  virtual void AttachAudioPlayer(AudioPlayerInterface& player);
105 #endif
106  virtual void DetachVideoRenderer();
109  virtual void DetachAudioPlayer();
111  void AddObserver(StreamObserver& observer);
113  void RemoveObserver(StreamObserver& observer);
114 
115  protected:
116  Stream(const std::string& id);
117  Stream();
118  virtual ~Stream();
119  void Id(const std::string& id);
120  void MediaStream(MediaStreamInterface* media_stream);
121  void TriggerOnStreamEnded();
122  void TriggerOnStreamUpdated();
123  void TriggerOnStreamMute(owt::base::TrackKind track_kind);
124  void TriggerOnStreamUnmute(owt::base::TrackKind track_kind);
125  MediaStreamInterface* media_stream_;
126  std::unordered_map<std::string, std::string> attributes_;
127  WebrtcVideoRendererImpl* renderer_impl_;
128  WebrtcAudioRendererImpl* audio_renderer_impl_;
129 #if defined(WEBRTC_WIN)
130  WebrtcVideoRendererD3D9Impl* d3d9_renderer_impl_;
131 #endif
132  StreamSourceInfo source_;
133 
134  private:
135  void SetAudioTracksEnabled(bool enabled);
136  void SetVideoTracksEnabled(bool enabled);
137  bool ended_;
138  std::string id_;
139  mutable std::mutex observer_mutex_;
140  std::vector<std::reference_wrapper<StreamObserver>> observers_;
141 };
143  public:
152  virtual void OnCaptureSourceNeeded(
153  const std::unordered_map<int, std::string>& window_list,
154  int& dest_window) {}
155  virtual ~LocalScreenStreamObserver() {}
156 };
161 class LocalStream : public Stream {
162  public:
163 #if !defined(WEBRTC_WIN)
164  LocalStream();
165  LocalStream(MediaStreamInterface* media_stream, StreamSourceInfo source);
166 #endif
167  virtual ~LocalStream();
168  using Stream::Attributes;
174  virtual void Attributes(
175  const std::unordered_map<std::string, std::string>& attributes) {
176  attributes_ = attributes;
177  }
183  void Close();
192  static std::shared_ptr<LocalStream> Create(
193  const LocalCameraStreamParameters& parameters,
194  int& error_code);
204  static std::shared_ptr<LocalStream> Create(
205  const bool is_audio_enabled,
206  webrtc::VideoTrackSourceInterface* video_source,
207  int& error_code);
220  static std::shared_ptr<LocalStream> Create(
221  std::shared_ptr<LocalCustomizedStreamParameters> parameters,
222  std::unique_ptr<VideoFrameGeneratorInterface> framer);
233  static std::shared_ptr<LocalStream> Create(
234  std::shared_ptr<LocalCustomizedStreamParameters> parameters,
235  VideoEncoderInterface* encoder);
244  static std::shared_ptr<LocalStream> Create(
245  std::shared_ptr<LocalDesktopStreamParameters> parameters,
246  std::unique_ptr<LocalScreenStreamObserver> observer);
247 
248  protected:
249  explicit LocalStream(const LocalCameraStreamParameters& parameters,
250  int& error_code);
251  explicit LocalStream(const bool is_audio_enabled,
252  webrtc::VideoTrackSourceInterface* video_source,
253  int& error_code);
254  explicit LocalStream(
255  std::shared_ptr<LocalCustomizedStreamParameters> parameters,
256  std::unique_ptr<VideoFrameGeneratorInterface> framer);
257  explicit LocalStream(
258  std::shared_ptr<LocalCustomizedStreamParameters> parameters,
259  VideoEncoderInterface* encoder);
260  explicit LocalStream(std::shared_ptr<LocalDesktopStreamParameters> parameters,
261  std::unique_ptr<LocalScreenStreamObserver> observer);
262 
263  private:
264  bool encoded_ = false;
265 #if defined(WEBRTC_MAC)
266  std::unique_ptr<ObjcVideoCapturerInterface> capturer_;
267 #endif
268 };
274 class RemoteStream : public Stream {
275  friend class owt::conference::ConferencePeerConnectionChannel;
277  friend class owt::conference::ConferenceInfo;
278  friend class owt::p2p::P2PPeerConnectionChannel;
279 
280  public:
282  explicit RemoteStream(
283  const std::string& id,
284  const std::string& from,
285  const owt::base::SubscriptionCapabilities& subscription_capabilities,
286  const owt::base::PublicationSettings& publication_settings);
287  explicit RemoteStream(MediaStreamInterface* media_stream,
288  const std::string& from);
289  virtual void Attributes(
290  const std::unordered_map<std::string, std::string>& attributes) {
291  attributes_ = attributes;
292  }
294  std::string Origin();
297  using Stream::Attributes;
299  SubscriptionCapabilities Capabilities() { return subscription_capabilities_; }
301  PublicationSettings Settings() { return publication_settings_; }
303 
304  void Capabilities(
306  const owt::base::SubscriptionCapabilities& subscription_capabilities) {
307  subscription_capabilities_ = subscription_capabilities;
308  }
310  void Settings(const PublicationSettings& publication_settings) {
311  publication_settings_ = publication_settings;
312  }
314  void Stop() {}
315 
316  protected:
317  MediaStreamInterface* MediaStream();
318  void MediaStream(MediaStreamInterface* media_stream);
319 
320  private:
321  std::string origin_;
322  bool has_audio_ = true;
323  bool has_video_ = true;
324  owt::base::SubscriptionCapabilities subscription_capabilities_;
325  owt::base::PublicationSettings publication_settings_;
326 };
327 } // namespace base
328 } // namespace owt
329 #endif // OWT_BASE_STREAM_H_
Video encoder interface.
Definition: videoencoderinterface.h:16
virtual void OnMute(TrackKind track_kind)
Triggered when the stream is muted.
Definition: stream.h:49
void RemoveObserver(StreamObserver &observer)
De-Register an observer on the stream.
Observer for Stream.
Definition: stream.h:41
Information about the conference.
Definition: conferenceclient.h:98
virtual void DisableAudio()
Disable all audio tracks of the stream.
virtual std::string Id() const
Get the ID of the stream.
An asynchronous class for app to communicate with a conference in MCU.
Definition: conferenceclient.h:212
virtual void DetachVideoRenderer()
Detach the stream from its renderer.
Definition: stream.h:142
This class represents a remote stream.
Definition: stream.h:274
virtual StreamSourceInfo Source() const
Returns the audio/video source info of the stream.
virtual void Attributes(const std::unordered_map< std::string, std::string > &attributes)
Set a user-defined attribute map.
Definition: stream.h:174
virtual void AttachVideoRenderer(VideoRendererInterface &renderer)
virtual void OnUnmute(TrackKind track_kind)
Triggered when the stream is unmuted.
Definition: stream.h:51
void AddObserver(StreamObserver &observer)
Register an observer on the stream.
Definition: options.h:43
Definition: stream.h:17
virtual void DisableVideo()
Disable all video tracks of the stream.
Definition: audioplayerinterface.h:8
SubscriptionCapabilities Capabilities()
Get the subscription capabilities on the stream.
Definition: stream.h:299
VideoRenderWindow wraps a native Window handle.
Definition: videorendererinterface.h:36
virtual const std::unordered_map< std::string, std::string > Attributes() const
Returns a user-defined attribute map.
Definition: stream.h:83
virtual void AttachAudioPlayer(AudioPlayerInterface &player)
Base class of all streams with media stream.
Definition: stream.h:59
virtual void OnCaptureSourceNeeded(const std::unordered_map< int, std::string > &window_list, int &dest_window)
Event callback for local screen stream to request for a source from application.
Definition: stream.h:152
Definition: options.h:28
virtual void EnableAudio()
Enable all audio tracks of the stream.
PublicationSettings Settings()
Get the publication settings of the stream.
Definition: stream.h:301
Stream source.
Definition: commontypes.h:157
This class contains parameters and methods that needed for creating a local camera stream...
Definition: localcamerastreamparameters.h:17
void Close()
Close a local stream.
virtual void OnUpdated()
Triggered when the stream info is updated in conference mode.
Definition: stream.h:47
void Stop()
Stop the remote stream.
Definition: stream.h:314
This class represents a local stream.
Definition: stream.h:161
static std::shared_ptr< LocalStream > Create(const LocalCameraStreamParameters &parameters, int &error_code)
Create a local camera stream. This creates a local camera stream with specified device settings...
virtual void DetachAudioPlayer()
Detach the stream from the audio player.
virtual void OnEnded()
Definition: stream.h:45
Interface for rendering VideoFrames in ARGB/I420 format from a VideoTrack.
Definition: videorendererinterface.h:74
virtual void EnableVideo()
Enable all video tracks of the stream.
Interface for rendering PCM data in a stream.
Definition: audioplayerinterface.h:11