Home | History | Annotate | Download | only in media 
      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_SESSION_MEDIA_CHANNELMANAGER_H_
     29 #define TALK_SESSION_MEDIA_CHANNELMANAGER_H_
     30 
     31 #include <string>
     32 #include <vector>
     33 
     34 #include "talk/base/criticalsection.h"
     35 #include "talk/base/sigslotrepeater.h"
     36 #include "talk/base/thread.h"
     37 #include "talk/media/base/capturemanager.h"
     38 #include "talk/media/base/mediaengine.h"
     39 #include "talk/p2p/base/session.h"
     40 #include "talk/session/media/voicechannel.h"
     41 
     42 namespace cricket {
     43 
     44 class Soundclip;
     45 class VideoProcessor;
     46 class VoiceChannel;
     47 class VoiceProcessor;
     48 
     49 // ChannelManager allows the MediaEngine to run on a separate thread, and takes
     50 // care of marshalling calls between threads. It also creates and keeps track of
     51 // voice and video channels; by doing so, it can temporarily pause all the
     52 // channels when a new audio or video device is chosen. The voice and video
     53 // channels are stored in separate vectors, to easily allow operations on just
     54 // voice or just video channels.
     55 // ChannelManager also allows the application to discover what devices it has
     56 // using device manager.
     57 class ChannelManager : public talk_base::MessageHandler,
     58                        public sigslot::has_slots<> {
     59  public:
     60 #if !defined(DISABLE_MEDIA_ENGINE_FACTORY)
     61   // Creates the channel manager, and specifies the worker thread to use.
     62   explicit ChannelManager(talk_base::Thread* worker);
     63 #endif
     64 
     65   // For testing purposes. Allows the media engine and data media
     66   // engine and dev manager to be mocks.  The ChannelManager takes
     67   // ownership of these objects.
     68   ChannelManager(MediaEngineInterface* me,
     69                  DataEngineInterface* dme,
     70                  DeviceManagerInterface* dm,
     71                  CaptureManager* cm,
     72                  talk_base::Thread* worker);
     73   // Same as above, but gives an easier default DataEngine.
     74   ChannelManager(MediaEngineInterface* me,
     75                  DeviceManagerInterface* dm,
     76                  talk_base::Thread* worker);
     77   ~ChannelManager();
     78 
     79   // Accessors for the worker thread, allowing it to be set after construction,
     80   // but before Init. set_worker_thread will return false if called after Init.
     81   talk_base::Thread* worker_thread() const { return worker_thread_; }
     82   bool set_worker_thread(talk_base::Thread* thread) {
     83     if (initialized_) return false;
     84     worker_thread_ = thread;
     85     return true;
     86   }
     87 
     88   // Gets capabilities. Can be called prior to starting the media engine.
     89   int GetCapabilities();
     90 
     91   // Retrieves the list of supported audio & video codec types.
     92   // Can be called before starting the media engine.
     93   void GetSupportedAudioCodecs(std::vector<AudioCodec>* codecs) const;
     94   void GetSupportedAudioRtpHeaderExtensions(RtpHeaderExtensions* ext) const;
     95   void GetSupportedVideoCodecs(std::vector<VideoCodec>* codecs) const;
     96   void GetSupportedVideoRtpHeaderExtensions(RtpHeaderExtensions* ext) const;
     97   void GetSupportedDataCodecs(std::vector<DataCodec>* codecs) const;
     98 
     99   // Indicates whether the media engine is started.
    100   bool initialized() const { return initialized_; }
    101   // Starts up the media engine.
    102   bool Init();
    103   // Shuts down the media engine.
    104   void Terminate();
    105 
    106   // The operations below all occur on the worker thread.
    107 
    108   // Creates a voice channel, to be associated with the specified session.
    109   VoiceChannel* CreateVoiceChannel(
    110       BaseSession* session, const std::string& content_name, bool rtcp);
    111   // Destroys a voice channel created with the Create API.
    112   void DestroyVoiceChannel(VoiceChannel* voice_channel);
    113   // Creates a video channel, synced with the specified voice channel, and
    114   // associated with the specified session.
    115   VideoChannel* CreateVideoChannel(
    116       BaseSession* session, const std::string& content_name, bool rtcp,
    117       VoiceChannel* voice_channel);
    118   // Destroys a video channel created with the Create API.
    119   void DestroyVideoChannel(VideoChannel* video_channel);
    120   DataChannel* CreateDataChannel(
    121       BaseSession* session, const std::string& content_name,
    122       bool rtcp, DataChannelType data_channel_type);
    123   // Destroys a data channel created with the Create API.
    124   void DestroyDataChannel(DataChannel* data_channel);
    125 
    126   // Creates a soundclip.
    127   Soundclip* CreateSoundclip();
    128   // Destroys a soundclip created with the Create API.
    129   void DestroySoundclip(Soundclip* soundclip);
    130 
    131   // Indicates whether any channels exist.
    132   bool has_channels() const {
    133     return (!voice_channels_.empty() || !video_channels_.empty() ||
    134             !soundclips_.empty());
    135   }
    136 
    137   // Configures the audio and video devices. A null pointer can be passed to
    138   // GetAudioOptions() for any parameter of no interest.
    139   bool GetAudioOptions(std::string* wave_in_device,
    140                        std::string* wave_out_device,
    141                        AudioOptions* options);
    142   bool SetAudioOptions(const std::string& wave_in_device,
    143                        const std::string& wave_out_device,
    144                        const AudioOptions& options);
    145   bool GetOutputVolume(int* level);
    146   bool SetOutputVolume(int level);
    147   bool IsSameCapturer(const std::string& capturer_name,
    148                       VideoCapturer* capturer);
    149   // TODO(noahric): Nearly everything called "device" in this API is actually a
    150   // device name, so this should really be GetCaptureDeviceName, and the
    151   // next method should be GetCaptureDevice.
    152   bool GetCaptureDevice(std::string* cam_device);
    153   // Gets the current capture Device.
    154   bool GetVideoCaptureDevice(Device* device);
    155   // Create capturer based on what has been set in SetCaptureDevice().
    156   VideoCapturer* CreateVideoCapturer();
    157   bool SetCaptureDevice(const std::string& cam_device);
    158   bool SetDefaultVideoEncoderConfig(const VideoEncoderConfig& config);
    159   // RTX will be enabled/disabled in engines that support it. The supporting
    160   // engines will start offering an RTX codec. Must be called before Init().
    161   bool SetVideoRtxEnabled(bool enable);
    162 
    163   // Starts/stops the local microphone and enables polling of the input level.
    164   bool SetLocalMonitor(bool enable);
    165   bool monitoring() const { return monitoring_; }
    166   // Sets the local renderer where to renderer the local camera.
    167   bool SetLocalRenderer(VideoRenderer* renderer);
    168   bool capturing() const { return capturing_; }
    169 
    170   // Configures the logging output of the mediaengine(s).
    171   void SetVoiceLogging(int level, const char* filter);
    172   void SetVideoLogging(int level, const char* filter);
    173 
    174   // The channel manager handles the Tx side for Video processing,
    175   // as well as Tx and Rx side for Voice processing.
    176   // (The Rx Video processing will go throug the simplerenderingmanager,
    177   //  to be implemented).
    178   bool RegisterVideoProcessor(VideoCapturer* capturer,
    179                               VideoProcessor* processor);
    180   bool UnregisterVideoProcessor(VideoCapturer* capturer,
    181                                 VideoProcessor* processor);
    182   bool RegisterVoiceProcessor(uint32 ssrc,
    183                               VoiceProcessor* processor,
    184                               MediaProcessorDirection direction);
    185   bool UnregisterVoiceProcessor(uint32 ssrc,
    186                                 VoiceProcessor* processor,
    187                                 MediaProcessorDirection direction);
    188   // The following are done in the new "CaptureManager" style that
    189   // all local video capturers, processors, and managers should move to.
    190   // TODO(pthatcher): Make methods nicer by having start return a handle that
    191   // can be used for stop and restart, rather than needing to pass around
    192   // formats a a pseudo-handle.
    193   bool StartVideoCapture(VideoCapturer* video_capturer,
    194                          const VideoFormat& video_format);
    195   // When muting, produce black frames then pause the camera.
    196   // When unmuting, start the camera. Camera starts unmuted.
    197   bool MuteToBlackThenPause(VideoCapturer* video_capturer, bool muted);
    198   bool StopVideoCapture(VideoCapturer* video_capturer,
    199                         const VideoFormat& video_format);
    200   bool RestartVideoCapture(VideoCapturer* video_capturer,
    201                            const VideoFormat& previous_format,
    202                            const VideoFormat& desired_format,
    203                            CaptureManager::RestartOptions options);
    204 
    205   bool AddVideoRenderer(VideoCapturer* capturer, VideoRenderer* renderer);
    206   bool RemoveVideoRenderer(VideoCapturer* capturer, VideoRenderer* renderer);
    207   bool IsScreencastRunning() const;
    208 
    209   // The operations below occur on the main thread.
    210 
    211   bool GetAudioInputDevices(std::vector<std::string>* names);
    212   bool GetAudioOutputDevices(std::vector<std::string>* names);
    213   bool GetVideoCaptureDevices(std::vector<std::string>* names);
    214   void SetVideoCaptureDeviceMaxFormat(const std::string& usb_id,
    215                                       const VideoFormat& max_format);
    216 
    217   sigslot::repeater0<> SignalDevicesChange;
    218   sigslot::signal2<VideoCapturer*, CaptureState> SignalVideoCaptureStateChange;
    219 
    220   // Returns the current selected device. Note: Subtly different from
    221   // GetCaptureDevice(). See member video_device_ for more details.
    222   // This API is mainly a hook used by unittests.
    223   const std::string& video_device_name() const { return video_device_name_; }
    224 
    225   // TODO(hellner): Remove this function once the engine capturer has been
    226   // removed.
    227   VideoFormat GetStartCaptureFormat();
    228 
    229   // TODO(turajs): Remove this function when ACM2 is in use. Used mainly to
    230   // choose between ACM1 and ACM2.
    231   bool SetAudioOptions(const AudioOptions& options);
    232 
    233  protected:
    234   // Adds non-transient parameters which can only be changed through the
    235   // options store.
    236   bool SetAudioOptions(const std::string& wave_in_device,
    237                        const std::string& wave_out_device,
    238                        const AudioOptions& options,
    239                        int delay_offset);
    240   int audio_delay_offset() const { return audio_delay_offset_; }
    241 
    242  private:
    243   typedef std::vector<VoiceChannel*> VoiceChannels;
    244   typedef std::vector<VideoChannel*> VideoChannels;
    245   typedef std::vector<DataChannel*> DataChannels;
    246   typedef std::vector<Soundclip*> Soundclips;
    247 
    248   void Construct(MediaEngineInterface* me,
    249                  DataEngineInterface* dme,
    250                  DeviceManagerInterface* dm,
    251                  CaptureManager* cm,
    252                  talk_base::Thread* worker_thread);
    253   void Terminate_w();
    254   VoiceChannel* CreateVoiceChannel_w(
    255       BaseSession* session, const std::string& content_name, bool rtcp);
    256   void DestroyVoiceChannel_w(VoiceChannel* voice_channel);
    257   VideoChannel* CreateVideoChannel_w(
    258       BaseSession* session, const std::string& content_name, bool rtcp,
    259       VoiceChannel* voice_channel);
    260   void DestroyVideoChannel_w(VideoChannel* video_channel);
    261   DataChannel* CreateDataChannel_w(
    262       BaseSession* session, const std::string& content_name,
    263       bool rtcp, DataChannelType data_channel_type);
    264   void DestroyDataChannel_w(DataChannel* data_channel);
    265   Soundclip* CreateSoundclip_w();
    266   void DestroySoundclip_w(Soundclip* soundclip);
    267   bool SetAudioOptions_w(const AudioOptions& options, int delay_offset,
    268                          const Device* in_dev, const Device* out_dev);
    269   bool SetCaptureDevice_w(const Device* cam_device);
    270   void OnVideoCaptureStateChange(VideoCapturer* capturer,
    271                                  CaptureState result);
    272   bool RegisterVideoProcessor_w(VideoCapturer* capturer,
    273                                 VideoProcessor* processor);
    274   bool UnregisterVideoProcessor_w(VideoCapturer* capturer,
    275                                   VideoProcessor* processor);
    276   bool IsScreencastRunning_w() const;
    277   virtual void OnMessage(talk_base::Message *message);
    278 
    279   talk_base::scoped_ptr<MediaEngineInterface> media_engine_;
    280   talk_base::scoped_ptr<DataEngineInterface> data_media_engine_;
    281   talk_base::scoped_ptr<DeviceManagerInterface> device_manager_;
    282   talk_base::scoped_ptr<CaptureManager> capture_manager_;
    283   bool initialized_;
    284   talk_base::Thread* main_thread_;
    285   talk_base::Thread* worker_thread_;
    286 
    287   VoiceChannels voice_channels_;
    288   VideoChannels video_channels_;
    289   DataChannels data_channels_;
    290   Soundclips soundclips_;
    291 
    292   std::string audio_in_device_;
    293   std::string audio_out_device_;
    294   AudioOptions audio_options_;
    295   int audio_delay_offset_;
    296   int audio_output_volume_;
    297   std::string camera_device_;
    298   VideoEncoderConfig default_video_encoder_config_;
    299   VideoRenderer* local_renderer_;
    300   bool enable_rtx_;
    301 
    302   bool capturing_;
    303   bool monitoring_;
    304 
    305   // String containing currently set device. Note that this string is subtly
    306   // different from camera_device_. E.g. camera_device_ will list unplugged
    307   // but selected devices while this sting will be empty or contain current
    308   // selected device.
    309   // TODO(hellner): refactor the code such that there is no need to keep two
    310   // strings for video devices that have subtle differences in behavior.
    311   std::string video_device_name_;
    312 };
    313 
    314 }  // namespace cricket
    315 
    316 #endif  // TALK_SESSION_MEDIA_CHANNELMANAGER_H_
    317