1 /*
2  * libjingle
3  * Copyright 2004 Google Inc.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *
8  *  1. Redistributions of source code must retain the above copyright notice,
9  *     this list of conditions and the following disclaimer.
10  *  2. Redistributions in binary form must reproduce the above copyright notice,
11  *     this list of conditions and the following disclaimer in the documentation
12  *     and/or other materials provided with the distribution.
13  *  3. The name of the author may not be used to endorse or promote products
14  *     derived from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 #ifndef TALK_MEDIA_BASE_MEDIAENGINE_H_
29 #define TALK_MEDIA_BASE_MEDIAENGINE_H_
30 
31 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
32 #include <CoreAudio/CoreAudio.h>
33 #endif
34 
35 #include <string>
36 #include <vector>
37 
38 #include "talk/media/base/codec.h"
39 #include "talk/media/base/mediachannel.h"
40 #include "talk/media/base/mediacommon.h"
41 #include "talk/media/base/videocapturer.h"
42 #include "talk/media/base/videocommon.h"
43 #include "talk/media/devices/devicemanager.h"
44 #include "webrtc/audio_state.h"
45 #include "webrtc/base/fileutils.h"
46 #include "webrtc/base/sigslotrepeater.h"
47 
48 #if defined(GOOGLE_CHROME_BUILD) || defined(CHROMIUM_BUILD)
49 #define DISABLE_MEDIA_ENGINE_FACTORY
50 #endif
51 
52 namespace webrtc {
53 class Call;
54 }
55 
56 namespace cricket {
57 
58 class VideoCapturer;
59 
60 struct RtpCapabilities {
61   std::vector<RtpHeaderExtension> header_extensions;
62 };
63 
64 // MediaEngineInterface is an abstraction of a media engine which can be
65 // subclassed to support different media componentry backends.
66 // It supports voice and video operations in the same class to facilitate
67 // proper synchronization between both media types.
68 class MediaEngineInterface {
69  public:
~MediaEngineInterface()70   virtual ~MediaEngineInterface() {}
71 
72   // Initialization
73   // Starts the engine.
74   virtual bool Init(rtc::Thread* worker_thread) = 0;
75   // Shuts down the engine.
76   virtual void Terminate() = 0;
77   // TODO(solenberg): Remove once VoE API refactoring is done.
78   virtual rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const = 0;
79 
80   // MediaChannel creation
81   // Creates a voice media channel. Returns NULL on failure.
82   virtual VoiceMediaChannel* CreateChannel(
83       webrtc::Call* call,
84       const AudioOptions& options) = 0;
85   // Creates a video media channel, paired with the specified voice channel.
86   // Returns NULL on failure.
87   virtual VideoMediaChannel* CreateVideoChannel(
88       webrtc::Call* call,
89       const VideoOptions& options) = 0;
90 
91   // Device configuration
92   // Gets the current speaker volume, as a value between 0 and 255.
93   virtual bool GetOutputVolume(int* level) = 0;
94   // Sets the current speaker volume, as a value between 0 and 255.
95   virtual bool SetOutputVolume(int level) = 0;
96 
97   // Gets the current microphone level, as a value between 0 and 10.
98   virtual int GetInputLevel() = 0;
99 
100   virtual const std::vector<AudioCodec>& audio_codecs() = 0;
101   virtual RtpCapabilities GetAudioCapabilities() = 0;
102   virtual const std::vector<VideoCodec>& video_codecs() = 0;
103   virtual RtpCapabilities GetVideoCapabilities() = 0;
104 
105   // Starts AEC dump using existing file.
106   virtual bool StartAecDump(rtc::PlatformFile file) = 0;
107 
108   // Stops recording AEC dump.
109   virtual void StopAecDump() = 0;
110 
111   // Starts RtcEventLog using existing file.
112   virtual bool StartRtcEventLog(rtc::PlatformFile file) = 0;
113 
114   // Stops recording an RtcEventLog.
115   virtual void StopRtcEventLog() = 0;
116 };
117 
118 
119 #if !defined(DISABLE_MEDIA_ENGINE_FACTORY)
120 class MediaEngineFactory {
121  public:
122   typedef cricket::MediaEngineInterface* (*MediaEngineCreateFunction)();
123   // Creates a media engine, using either the compiled system default or the
124   // creation function specified in SetCreateFunction, if specified.
125   static MediaEngineInterface* Create();
126   // Sets the function used when calling Create. If unset, the compiled system
127   // default will be used. Returns the old create function, or NULL if one
128   // wasn't set. Likewise, NULL can be used as the |function| parameter to
129   // reset to the default behavior.
130   static MediaEngineCreateFunction SetCreateFunction(
131       MediaEngineCreateFunction function);
132  private:
133   static MediaEngineCreateFunction create_function_;
134 };
135 #endif
136 
137 // CompositeMediaEngine constructs a MediaEngine from separate
138 // voice and video engine classes.
139 template<class VOICE, class VIDEO>
140 class CompositeMediaEngine : public MediaEngineInterface {
141  public:
~CompositeMediaEngine()142   virtual ~CompositeMediaEngine() {}
Init(rtc::Thread * worker_thread)143   virtual bool Init(rtc::Thread* worker_thread) {
144     if (!voice_.Init(worker_thread))
145       return false;
146     video_.Init();
147     return true;
148   }
Terminate()149   virtual void Terminate() {
150     voice_.Terminate();
151   }
152 
GetAudioState()153   virtual rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const {
154     return voice_.GetAudioState();
155   }
CreateChannel(webrtc::Call * call,const AudioOptions & options)156   virtual VoiceMediaChannel* CreateChannel(webrtc::Call* call,
157                                            const AudioOptions& options) {
158     return voice_.CreateChannel(call, options);
159   }
CreateVideoChannel(webrtc::Call * call,const VideoOptions & options)160   virtual VideoMediaChannel* CreateVideoChannel(webrtc::Call* call,
161                                                 const VideoOptions& options) {
162     return video_.CreateChannel(call, options);
163   }
164 
GetOutputVolume(int * level)165   virtual bool GetOutputVolume(int* level) {
166     return voice_.GetOutputVolume(level);
167   }
SetOutputVolume(int level)168   virtual bool SetOutputVolume(int level) {
169     return voice_.SetOutputVolume(level);
170   }
171 
GetInputLevel()172   virtual int GetInputLevel() {
173     return voice_.GetInputLevel();
174   }
audio_codecs()175   virtual const std::vector<AudioCodec>& audio_codecs() {
176     return voice_.codecs();
177   }
GetAudioCapabilities()178   virtual RtpCapabilities GetAudioCapabilities() {
179     return voice_.GetCapabilities();
180   }
video_codecs()181   virtual const std::vector<VideoCodec>& video_codecs() {
182     return video_.codecs();
183   }
GetVideoCapabilities()184   virtual RtpCapabilities GetVideoCapabilities() {
185     return video_.GetCapabilities();
186   }
187 
StartAecDump(rtc::PlatformFile file)188   virtual bool StartAecDump(rtc::PlatformFile file) {
189     return voice_.StartAecDump(file);
190   }
191 
StopAecDump()192   virtual void StopAecDump() {
193     voice_.StopAecDump();
194   }
195 
StartRtcEventLog(rtc::PlatformFile file)196   virtual bool StartRtcEventLog(rtc::PlatformFile file) {
197     return voice_.StartRtcEventLog(file);
198   }
199 
StopRtcEventLog()200   virtual void StopRtcEventLog() { voice_.StopRtcEventLog(); }
201 
202  protected:
203   VOICE voice_;
204   VIDEO video_;
205 };
206 
207 enum DataChannelType {
208   DCT_NONE = 0,
209   DCT_RTP = 1,
210   DCT_SCTP = 2
211 };
212 
213 class DataEngineInterface {
214  public:
~DataEngineInterface()215   virtual ~DataEngineInterface() {}
216   virtual DataMediaChannel* CreateChannel(DataChannelType type) = 0;
217   virtual const std::vector<DataCodec>& data_codecs() = 0;
218 };
219 
220 }  // namespace cricket
221 
222 #endif  // TALK_MEDIA_BASE_MEDIAENGINE_H_
223