src/third_party/libjingle/source/talk/session/media/channelmanager.cc

   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 #include "talk/session/media/channelmanager.h"
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif
  33
  34 #include <algorithm>
  35
  36 #include "talk/media/base/capturemanager.h"
  37 #include "talk/media/base/hybriddataengine.h"
  38 #include "talk/media/base/rtpdataengine.h"
  39 #include "talk/media/base/videocapturer.h"
  40 #include "talk/media/devices/devicemanager.h"
  41 #ifdef HAVE_SCTP
  42 #include "talk/media/sctp/sctpdataengine.h"
  43 #endif
  44 #include "talk/session/media/soundclip.h"
  45 #include "talk/session/media/srtpfilter.h"
  46 #include "webrtc/base/bind.h"
  47 #include "webrtc/base/common.h"
  48 #include "webrtc/base/logging.h"
  49 #include "webrtc/base/sigslotrepeater.h"
  50 #include "webrtc/base/stringencode.h"
  51 #include "webrtc/base/stringutils.h"
  52
  53 namespace cricket {
  54
  55 enum {
  56   MSG_VIDEOCAPTURESTATE = 1,
  57 };
  58
  59 using rtc::Bind;
  60
  61 static const int kNotSetOutputVolume = -1;
  62
  63 struct CaptureStateParams : public rtc::MessageData {
  64   CaptureStateParams(cricket::VideoCapturer* c, cricket::CaptureState s)
  65       : capturer(c),
  66         state(s) {}
  67   cricket::VideoCapturer* capturer;
  68   cricket::CaptureState state;
  69 };
  70
  71 static DataEngineInterface* ConstructDataEngine() {
  72 #ifdef HAVE_SCTP
  73   return new HybridDataEngine(new RtpDataEngine(), new SctpDataEngine());
  74 #else
  75   return new RtpDataEngine();
  76 #endif
  77 }
  78
  79 #if !defined(DISABLE_MEDIA_ENGINE_FACTORY)
  80 ChannelManager::ChannelManager(rtc::Thread* worker_thread) {
  81   Construct(MediaEngineFactory::Create(),
  82             ConstructDataEngine(),
  83             cricket::DeviceManagerFactory::Create(),
  84             new CaptureManager(),
  85             worker_thread);
  86 }
  87 #endif
  88
  89 ChannelManager::ChannelManager(MediaEngineInterface* me,
  90                                DataEngineInterface* dme,
  91                                DeviceManagerInterface* dm,
  92                                CaptureManager* cm,
  93                                rtc::Thread* worker_thread) {
  94   Construct(me, dme, dm, cm, worker_thread);
  95 }
  96
  97 ChannelManager::ChannelManager(MediaEngineInterface* me,
  98                                DeviceManagerInterface* dm,
  99                                rtc::Thread* worker_thread) {
 100   Construct(me,
 101             ConstructDataEngine(),
 102             dm,
 103             new CaptureManager(),
 104             worker_thread);
 105 }
 106
 107 void ChannelManager::Construct(MediaEngineInterface* me,
 108                                DataEngineInterface* dme,
 109                                DeviceManagerInterface* dm,
 110                                CaptureManager* cm,
 111                                rtc::Thread* worker_thread) {
 112   media_engine_.reset(me);
 113   data_media_engine_.reset(dme);
 114   device_manager_.reset(dm);
 115   capture_manager_.reset(cm);
 116   initialized_ = false;
 117   main_thread_ = rtc::Thread::Current();
 118   worker_thread_ = worker_thread;
 119   // Get the default audio options from the media engine.
 120   audio_options_ = media_engine_->GetAudioOptions();
 121   audio_in_device_ = DeviceManagerInterface::kDefaultDeviceName;
 122   audio_out_device_ = DeviceManagerInterface::kDefaultDeviceName;
 123   audio_delay_offset_ = kDefaultAudioDelayOffset;
 124   audio_output_volume_ = kNotSetOutputVolume;
 125   local_renderer_ = NULL;
 126   capturing_ = false;
 127   monitoring_ = false;
 128   enable_rtx_ = false;
 129
 130   // Init the device manager immediately, and set up our default video device.
 131   SignalDevicesChange.repeat(device_manager_->SignalDevicesChange);
 132   device_manager_->Init();
 133
 134   // Camera is started asynchronously, request callbacks when startup
 135   // completes to be able to forward them to the rendering manager.
 136   media_engine_->SignalVideoCaptureStateChange().connect(
 137       this, &ChannelManager::OnVideoCaptureStateChange);
 138   capture_manager_->SignalCapturerStateChange.connect(
 139       this, &ChannelManager::OnVideoCaptureStateChange);
 140
 141   if (worker_thread_ != rtc::Thread::Current()) {
 142     // Do not allow invoking calls to other threads on the worker thread.
 143     worker_thread_->Invoke<bool>(
 144         rtc::Bind(&rtc::Thread::SetAllowBlockingCalls, worker_thread_, false));
 145   }
 146 }
 147
 148 ChannelManager::~ChannelManager() {
 149   if (initialized_) {
 150     Terminate();
 151     // If srtp is initialized (done by the Channel) then we must call
 152     // srtp_shutdown to free all crypto kernel lists. But we need to make sure
 153     // shutdown always called at the end, after channels are destroyed.
 154     // ChannelManager d'tor is always called last, it's safe place to call
 155     // shutdown.
 156     ShutdownSrtp();
 157   }
 158 }
 159
 160 bool ChannelManager::SetVideoRtxEnabled(bool enable) {
 161   // To be safe, this call is only allowed before initialization. Apps like
 162   // Flute only have a singleton ChannelManager and we don't want this flag to
 163   // be toggled between calls or when there's concurrent calls. We expect apps
 164   // to enable this at startup and retain that setting for the lifetime of the
 165   // app.
 166   if (!initialized_) {
 167     enable_rtx_ = enable;
 168     return true;
 169   } else {
 170     LOG(LS_WARNING) << "Cannot toggle rtx after initialization!";
 171     return false;
 172   }
 173 }
 174
 175 int ChannelManager::GetCapabilities() {
 176   return media_engine_->GetCapabilities() & device_manager_->GetCapabilities();
 177 }
 178
 179 void ChannelManager::GetSupportedAudioCodecs(
 180     std::vector<AudioCodec>* codecs) const {
 181   codecs->clear();
 182
 183   for (std::vector<AudioCodec>::const_iterator it =
 184            media_engine_->audio_codecs().begin();
 185       it != media_engine_->audio_codecs().end(); ++it) {
 186     codecs->push_back(*it);
 187   }
 188 }
 189
 190 void ChannelManager::GetSupportedAudioRtpHeaderExtensions(
 191     RtpHeaderExtensions* ext) const {
 192   *ext = media_engine_->audio_rtp_header_extensions();
 193 }
 194
 195 void ChannelManager::GetSupportedVideoCodecs(
 196     std::vector<VideoCodec>* codecs) const {
 197   codecs->clear();
 198
 199   std::vector<VideoCodec>::const_iterator it;
 200   for (it = media_engine_->video_codecs().begin();
 201       it != media_engine_->video_codecs().end(); ++it) {
 202     if (!enable_rtx_ && _stricmp(kRtxCodecName, it->name.c_str()) == 0) {
 203       continue;
 204     }
 205     codecs->push_back(*it);
 206   }
 207 }
 208
 209 void ChannelManager::GetSupportedVideoRtpHeaderExtensions(
 210     RtpHeaderExtensions* ext) const {
 211   *ext = media_engine_->video_rtp_header_extensions();
 212 }
 213
 214 void ChannelManager::GetSupportedDataCodecs(
 215     std::vector<DataCodec>* codecs) const {
 216   *codecs = data_media_engine_->data_codecs();
 217 }
 218
 219 bool ChannelManager::Init() {
 220   ASSERT(!initialized_);
 221   if (initialized_) {
 222     return false;
 223   }
 224
 225   ASSERT(worker_thread_ != NULL);
 226   if (worker_thread_) {
 227     if (media_engine_->Init(worker_thread_)) {
 228       initialized_ = true;
 229
 230       // Now that we're initialized, apply any stored preferences. A preferred
 231       // device might have been unplugged. In this case, we fallback to the
 232       // default device but keep the user preferences. The preferences are
 233       // changed only when the Javascript FE changes them.
 234       const std::string preferred_audio_in_device = audio_in_device_;
 235       const std::string preferred_audio_out_device = audio_out_device_;
 236       const std::string preferred_camera_device = camera_device_;
 237       Device device;
 238       if (!device_manager_->GetAudioInputDevice(audio_in_device_, &device)) {
 239         LOG(LS_WARNING) << "The preferred microphone '" << audio_in_device_
 240                         << "' is unavailable. Fall back to the default.";
 241         audio_in_device_ = DeviceManagerInterface::kDefaultDeviceName;
 242       }
 243       if (!device_manager_->GetAudioOutputDevice(audio_out_device_, &device)) {
 244         LOG(LS_WARNING) << "The preferred speaker '" << audio_out_device_
 245                         << "' is unavailable. Fall back to the default.";
 246         audio_out_device_ = DeviceManagerInterface::kDefaultDeviceName;
 247       }
 248       if (!device_manager_->GetVideoCaptureDevice(camera_device_, &device)) {
 249         if (!camera_device_.empty()) {
 250           LOG(LS_WARNING) << "The preferred camera '" << camera_device_
 251                           << "' is unavailable. Fall back to the default.";
 252         }
 253         camera_device_ = DeviceManagerInterface::kDefaultDeviceName;
 254       }
 255
 256       if (!SetAudioOptions(audio_in_device_, audio_out_device_,
 257                            audio_options_, audio_delay_offset_)) {
 258         LOG(LS_WARNING) << "Failed to SetAudioOptions with"
 259                         << " microphone: " << audio_in_device_
 260                         << " speaker: " << audio_out_device_
 261                         << " options: " << audio_options_.ToString()
 262                         << " delay: " << audio_delay_offset_;
 263       }
 264
 265       // If audio_output_volume_ has been set via SetOutputVolume(), set the
 266       // audio output volume of the engine.
 267       if (kNotSetOutputVolume != audio_output_volume_ &&
 268           !SetOutputVolume(audio_output_volume_)) {
 269         LOG(LS_WARNING) << "Failed to SetOutputVolume to "
 270                         << audio_output_volume_;
 271       }
 272       if (!SetCaptureDevice(camera_device_) && !camera_device_.empty()) {
 273         LOG(LS_WARNING) << "Failed to SetCaptureDevice with camera: "
 274                         << camera_device_;
 275       }
 276
 277       // Restore the user preferences.
 278       audio_in_device_ = preferred_audio_in_device;
 279       audio_out_device_ = preferred_audio_out_device;
 280       camera_device_ = preferred_camera_device;
 281
 282       // Now apply the default video codec that has been set earlier.
 283       if (default_video_encoder_config_.max_codec.id != 0) {
 284         SetDefaultVideoEncoderConfig(default_video_encoder_config_);
 285       }
 286     }
 287   }
 288   return initialized_;
 289 }
 290
 291 void ChannelManager::Terminate() {
 292   ASSERT(initialized_);
 293   if (!initialized_) {
 294     return;
 295   }
 296   worker_thread_->Invoke<void>(Bind(&ChannelManager::Terminate_w, this));
 297   media_engine_->Terminate();
 298   initialized_ = false;
 299 }
 300
 301 void ChannelManager::Terminate_w() {
 302   ASSERT(worker_thread_ == rtc::Thread::Current());
 303   // Need to destroy the voice/video channels
 304   while (!video_channels_.empty()) {
 305     DestroyVideoChannel_w(video_channels_.back());
 306   }
 307   while (!voice_channels_.empty()) {
 308     DestroyVoiceChannel_w(voice_channels_.back());
 309   }
 310   while (!soundclips_.empty()) {
 311     DestroySoundclip_w(soundclips_.back());
 312   }
 313   if (!SetCaptureDevice_w(NULL)) {
 314     LOG(LS_WARNING) << "failed to delete video capturer";
 315   }
 316 }
 317
 318 VoiceChannel* ChannelManager::CreateVoiceChannel(
 319     BaseSession* session, const std::string& content_name, bool rtcp) {
 320   return worker_thread_->Invoke<VoiceChannel*>(
 321       Bind(&ChannelManager::CreateVoiceChannel_w, this,
 322            session, content_name, rtcp));
 323 }
 324
 325 VoiceChannel* ChannelManager::CreateVoiceChannel_w(
 326     BaseSession* session, const std::string& content_name, bool rtcp) {
 327   // This is ok to alloc from a thread other than the worker thread
 328   ASSERT(initialized_);
 329   VoiceMediaChannel* media_channel = media_engine_->CreateChannel();
 330   if (media_channel == NULL)
 331     return NULL;
 332
 333   VoiceChannel* voice_channel = new VoiceChannel(
 334       worker_thread_, media_engine_.get(), media_channel,
 335       session, content_name, rtcp);
 336   if (!voice_channel->Init()) {
 337     delete voice_channel;
 338     return NULL;
 339   }
 340   voice_channels_.push_back(voice_channel);
 341   return voice_channel;
 342 }
 343
 344 void ChannelManager::DestroyVoiceChannel(VoiceChannel* voice_channel) {
 345   if (voice_channel) {
 346     worker_thread_->Invoke<void>(
 347         Bind(&ChannelManager::DestroyVoiceChannel_w, this, voice_channel));
 348   }
 349 }
 350
 351 void ChannelManager::DestroyVoiceChannel_w(VoiceChannel* voice_channel) {
 352   // Destroy voice channel.
 353   ASSERT(initialized_);
 354   VoiceChannels::iterator it = std::find(voice_channels_.begin(),
 355       voice_channels_.end(), voice_channel);
 356   ASSERT(it != voice_channels_.end());
 357   if (it == voice_channels_.end())
 358     return;
 359
 360   voice_channels_.erase(it);
 361   delete voice_channel;
 362 }
 363
 364 VideoChannel* ChannelManager::CreateVideoChannel(
 365     BaseSession* session, const std::string& content_name, bool rtcp,
 366     VoiceChannel* voice_channel) {
 367   return worker_thread_->Invoke<VideoChannel*>(
 368       Bind(&ChannelManager::CreateVideoChannel_w, this, session,
 369            content_name, rtcp, voice_channel));
 370 }
 371
 372 VideoChannel* ChannelManager::CreateVideoChannel_w(
 373     BaseSession* session, const std::string& content_name, bool rtcp,
 374     VoiceChannel* voice_channel) {
 375   // This is ok to alloc from a thread other than the worker thread
 376   ASSERT(initialized_);
 377   VideoMediaChannel* media_channel =
 378       // voice_channel can be NULL in case of NullVoiceEngine.
 379       media_engine_->CreateVideoChannel(voice_channel ?
 380           voice_channel->media_channel() : NULL);
 381   if (media_channel == NULL)
 382     return NULL;
 383
 384   VideoChannel* video_channel = new VideoChannel(
 385       worker_thread_, media_engine_.get(), media_channel,
 386       session, content_name, rtcp, voice_channel);
 387   if (!video_channel->Init()) {
 388     delete video_channel;
 389     return NULL;
 390   }
 391   video_channels_.push_back(video_channel);
 392   return video_channel;
 393 }
 394
 395 void ChannelManager::DestroyVideoChannel(VideoChannel* video_channel) {
 396   if (video_channel) {
 397     worker_thread_->Invoke<void>(
 398         Bind(&ChannelManager::DestroyVideoChannel_w, this, video_channel));
 399   }
 400 }
 401
 402 void ChannelManager::DestroyVideoChannel_w(VideoChannel* video_channel) {
 403   // Destroy video channel.
 404   ASSERT(initialized_);
 405   VideoChannels::iterator it = std::find(video_channels_.begin(),
 406       video_channels_.end(), video_channel);
 407   ASSERT(it != video_channels_.end());
 408   if (it == video_channels_.end())
 409     return;
 410
 411   video_channels_.erase(it);
 412   delete video_channel;
 413 }
 414
 415 DataChannel* ChannelManager::CreateDataChannel(
 416     BaseSession* session, const std::string& content_name,
 417     bool rtcp, DataChannelType channel_type) {
 418   return worker_thread_->Invoke<DataChannel*>(
 419       Bind(&ChannelManager::CreateDataChannel_w, this, session, content_name,
 420            rtcp, channel_type));
 421 }
 422
 423 DataChannel* ChannelManager::CreateDataChannel_w(
 424     BaseSession* session, const std::string& content_name,
 425     bool rtcp, DataChannelType data_channel_type) {
 426   // This is ok to alloc from a thread other than the worker thread.
 427   ASSERT(initialized_);
 428   DataMediaChannel* media_channel = data_media_engine_->CreateChannel(
 429       data_channel_type);
 430   if (!media_channel) {
 431     LOG(LS_WARNING) << "Failed to create data channel of type "
 432                     << data_channel_type;
 433     return NULL;
 434   }
 435
 436   DataChannel* data_channel = new DataChannel(
 437       worker_thread_, media_channel,
 438       session, content_name, rtcp);
 439   if (!data_channel->Init()) {
 440     LOG(LS_WARNING) << "Failed to init data channel.";
 441     delete data_channel;
 442     return NULL;
 443   }
 444   data_channels_.push_back(data_channel);
 445   return data_channel;
 446 }
 447
 448 void ChannelManager::DestroyDataChannel(DataChannel* data_channel) {
 449   if (data_channel) {
 450     worker_thread_->Invoke<void>(
 451         Bind(&ChannelManager::DestroyDataChannel_w, this, data_channel));
 452   }
 453 }
 454
 455 void ChannelManager::DestroyDataChannel_w(DataChannel* data_channel) {
 456   // Destroy data channel.
 457   ASSERT(initialized_);
 458   DataChannels::iterator it = std::find(data_channels_.begin(),
 459       data_channels_.end(), data_channel);
 460   ASSERT(it != data_channels_.end());
 461   if (it == data_channels_.end())
 462     return;
 463
 464   data_channels_.erase(it);
 465   delete data_channel;
 466 }
 467
 468 Soundclip* ChannelManager::CreateSoundclip() {
 469   return worker_thread_->Invoke<Soundclip*>(
 470       Bind(&ChannelManager::CreateSoundclip_w, this));
 471 }
 472
 473 Soundclip* ChannelManager::CreateSoundclip_w() {
 474   ASSERT(initialized_);
 475   ASSERT(worker_thread_ == rtc::Thread::Current());
 476
 477   SoundclipMedia* soundclip_media = media_engine_->CreateSoundclip();
 478   if (!soundclip_media) {
 479     return NULL;
 480   }
 481
 482   Soundclip* soundclip = new Soundclip(worker_thread_, soundclip_media);
 483   soundclips_.push_back(soundclip);
 484   return soundclip;
 485 }
 486
 487 void ChannelManager::DestroySoundclip(Soundclip* soundclip) {
 488   if (soundclip) {
 489     worker_thread_->Invoke<void>(
 490         Bind(&ChannelManager::DestroySoundclip_w, this, soundclip));
 491   }
 492 }
 493
 494 void ChannelManager::DestroySoundclip_w(Soundclip* soundclip) {
 495   // Destroy soundclip.
 496   ASSERT(initialized_);
 497   Soundclips::iterator it = std::find(soundclips_.begin(),
 498       soundclips_.end(), soundclip);
 499   ASSERT(it != soundclips_.end());
 500   if (it == soundclips_.end())
 501     return;
 502
 503   soundclips_.erase(it);
 504   delete soundclip;
 505 }
 506
 507 bool ChannelManager::GetAudioOptions(std::string* in_name,
 508                                      std::string* out_name,
 509                                      AudioOptions* options) {
 510   if (in_name)
 511     *in_name = audio_in_device_;
 512   if (out_name)
 513     *out_name = audio_out_device_;
 514   if (options)
 515     *options = audio_options_;
 516   return true;
 517 }
 518
 519 bool ChannelManager::SetAudioOptions(const std::string& in_name,
 520                                      const std::string& out_name,
 521                                      const AudioOptions& options) {
 522   return SetAudioOptions(in_name, out_name, options, audio_delay_offset_);
 523 }
 524
 525 bool ChannelManager::SetAudioOptions(const std::string& in_name,
 526                                      const std::string& out_name,
 527                                      const AudioOptions& options,
 528                                      int delay_offset) {
 529   // Get device ids from DeviceManager.
 530   Device in_dev, out_dev;
 531   if (!device_manager_->GetAudioInputDevice(in_name, &in_dev)) {
 532     LOG(LS_WARNING) << "Failed to GetAudioInputDevice: " << in_name;
 533     return false;
 534   }
 535   if (!device_manager_->GetAudioOutputDevice(out_name, &out_dev)) {
 536     LOG(LS_WARNING) << "Failed to GetAudioOutputDevice: " << out_name;
 537     return false;
 538   }
 539
 540   // If we're initialized, pass the settings to the media engine.
 541   bool ret = true;
 542   if (initialized_) {
 543     ret = worker_thread_->Invoke<bool>(
 544         Bind(&ChannelManager::SetAudioOptions_w, this,
 545              options, delay_offset, &in_dev, &out_dev));
 546   }
 547
 548   // If all worked well, save the values for use in GetAudioOptions.
 549   if (ret) {
 550     audio_options_ = options;
 551     audio_in_device_ = in_name;
 552     audio_out_device_ = out_name;
 553     audio_delay_offset_ = delay_offset;
 554   }
 555   return ret;
 556 }
 557
 558 bool ChannelManager::SetAudioOptions_w(
 559     const AudioOptions& options, int delay_offset,
 560     const Device* in_dev, const Device* out_dev) {
 561   ASSERT(worker_thread_ == rtc::Thread::Current());
 562   ASSERT(initialized_);
 563
 564   // Set audio options
 565   bool ret = media_engine_->SetAudioOptions(options);
 566
 567   if (ret) {
 568     ret = media_engine_->SetAudioDelayOffset(delay_offset);
 569   }
 570
 571   // Set the audio devices
 572   if (ret) {
 573     ret = media_engine_->SetSoundDevices(in_dev, out_dev);
 574   }
 575
 576   return ret;
 577 }
 578
 579 // Sets Engine-specific audio options according to enabled experiments.
 580 bool ChannelManager::SetEngineAudioOptions(const AudioOptions& options) {
 581   // If we're initialized, pass the settings to the media engine.
 582   bool ret = false;
 583   if (initialized_) {
 584     ret = worker_thread_->Invoke<bool>(
 585         Bind(&ChannelManager::SetEngineAudioOptions_w, this, options));
 586   }
 587
 588   // If all worked well, save the audio options.
 589   if (ret) {
 590     audio_options_ = options;
 591   }
 592   return ret;
 593 }
 594
 595 bool ChannelManager::SetEngineAudioOptions_w(const AudioOptions& options) {
 596   ASSERT(worker_thread_ == rtc::Thread::Current());
 597   ASSERT(initialized_);
 598
 599   return media_engine_->SetAudioOptions(options);
 600 }
 601
 602 bool ChannelManager::GetOutputVolume(int* level) {
 603   if (!initialized_) {
 604     return false;
 605   }
 606   return worker_thread_->Invoke<bool>(
 607       Bind(&MediaEngineInterface::GetOutputVolume, media_engine_.get(), level));
 608 }
 609
 610 bool ChannelManager::SetOutputVolume(int level) {
 611   bool ret = level >= 0 && level <= 255;
 612   if (initialized_) {
 613     ret &= worker_thread_->Invoke<bool>(
 614         Bind(&MediaEngineInterface::SetOutputVolume,
 615              media_engine_.get(), level));
 616   }
 617
 618   if (ret) {
 619     audio_output_volume_ = level;
 620   }
 621
 622   return ret;
 623 }
 624
 625 bool ChannelManager::IsSameCapturer(const std::string& capturer_name,
 626                                     VideoCapturer* capturer) {
 627   if (capturer == NULL) {
 628     return false;
 629   }
 630   Device device;
 631   if (!device_manager_->GetVideoCaptureDevice(capturer_name, &device)) {
 632     return false;
 633   }
 634   return capturer->GetId() == device.id;
 635 }
 636
 637 bool ChannelManager::GetVideoCaptureDevice(Device* device) {
 638   std::string device_name;
 639   if (!GetCaptureDevice(&device_name)) {
 640     return false;
 641   }
 642   return device_manager_->GetVideoCaptureDevice(device_name, device);
 643 }
 644
 645 bool ChannelManager::GetCaptureDevice(std::string* cam_name) {
 646   if (camera_device_.empty()) {
 647     // Initialize camera_device_ with default.
 648     Device device;
 649     if (!device_manager_->GetVideoCaptureDevice(
 650         DeviceManagerInterface::kDefaultDeviceName, &device)) {
 651       LOG(LS_WARNING) << "Device manager can't find default camera: " <<
 652           DeviceManagerInterface::kDefaultDeviceName;
 653       return false;
 654     }
 655     camera_device_ = device.name;
 656   }
 657   *cam_name = camera_device_;
 658   return true;
 659 }
 660
 661 bool ChannelManager::SetCaptureDevice(const std::string& cam_name) {
 662   Device device;
 663   bool ret = true;
 664   if (!device_manager_->GetVideoCaptureDevice(cam_name, &device)) {
 665     if (!cam_name.empty()) {
 666       LOG(LS_WARNING) << "Device manager can't find camera: " << cam_name;
 667     }
 668     ret = false;
 669   }
 670
 671   // If we're running, tell the media engine about it.
 672   if (initialized_ && ret) {
 673     ret = worker_thread_->Invoke<bool>(
 674         Bind(&ChannelManager::SetCaptureDevice_w, this, &device));
 675   }
 676
 677   // If everything worked, retain the name of the selected camera.
 678   if (ret) {
 679     camera_device_ = device.name;
 680   } else if (camera_device_.empty()) {
 681     // When video option setting fails, we still want camera_device_ to be in a
 682     // good state, so we initialize it with default if it's empty.
 683     Device default_device;
 684     if (!device_manager_->GetVideoCaptureDevice(
 685         DeviceManagerInterface::kDefaultDeviceName, &default_device)) {
 686       LOG(LS_WARNING) << "Device manager can't find default camera: " <<
 687           DeviceManagerInterface::kDefaultDeviceName;
 688     }
 689     camera_device_ = default_device.name;
 690   }
 691
 692   return ret;
 693 }
 694
 695 VideoCapturer* ChannelManager::CreateVideoCapturer() {
 696   Device device;
 697   if (!device_manager_->GetVideoCaptureDevice(camera_device_, &device)) {
 698     if (!camera_device_.empty()) {
 699       LOG(LS_WARNING) << "Device manager can't find camera: " << camera_device_;
 700     }
 701     return NULL;
 702   }
 703   VideoCapturer* capturer = device_manager_->CreateVideoCapturer(device);
 704   if (capturer && default_video_encoder_config_.max_codec.id != 0) {
 705     // For now, use the aspect ratio of the default_video_encoder_config_,
 706     // which may be different than the native aspect ratio of the start
 707     // format the camera may use.
 708     capturer->UpdateAspectRatio(
 709         default_video_encoder_config_.max_codec.width,
 710         default_video_encoder_config_.max_codec.height);
 711   }
 712   return capturer;
 713 }
 714
 715 VideoCapturer* ChannelManager::CreateScreenCapturer(
 716     const ScreencastId& screenid) {
 717   return device_manager_->CreateScreenCapturer(screenid);
 718 }
 719
 720 bool ChannelManager::SetCaptureDevice_w(const Device* cam_device) {
 721   ASSERT(worker_thread_ == rtc::Thread::Current());
 722   ASSERT(initialized_);
 723
 724   if (!cam_device) {
 725     video_device_name_.clear();
 726     return true;
 727   }
 728   video_device_name_ = cam_device->name;
 729   return true;
 730 }
 731
 732 bool ChannelManager::SetDefaultVideoEncoderConfig(const VideoEncoderConfig& c) {
 733   bool ret = true;
 734   if (initialized_) {
 735     ret = worker_thread_->Invoke<bool>(
 736         Bind(&MediaEngineInterface::SetDefaultVideoEncoderConfig,
 737              media_engine_.get(), c));
 738   }
 739   if (ret) {
 740     default_video_encoder_config_ = c;
 741   }
 742   return ret;
 743 }
 744
 745 bool ChannelManager::SetLocalMonitor(bool enable) {
 746   bool ret = initialized_ && worker_thread_->Invoke<bool>(
 747       Bind(&MediaEngineInterface::SetLocalMonitor,
 748            media_engine_.get(), enable));
 749   if (ret) {
 750     monitoring_ = enable;
 751   }
 752   return ret;
 753 }
 754
 755 void ChannelManager::SetVoiceLogging(int level, const char* filter) {
 756   if (initialized_) {
 757     worker_thread_->Invoke<void>(
 758         Bind(&MediaEngineInterface::SetVoiceLogging,
 759              media_engine_.get(), level, filter));
 760   } else {
 761     media_engine_->SetVoiceLogging(level, filter);
 762   }
 763 }
 764
 765 void ChannelManager::SetVideoLogging(int level, const char* filter) {
 766   if (initialized_) {
 767     worker_thread_->Invoke<void>(
 768         Bind(&MediaEngineInterface::SetVideoLogging,
 769              media_engine_.get(), level, filter));
 770   } else {
 771     media_engine_->SetVideoLogging(level, filter);
 772   }
 773 }
 774
 775 // TODO(janahan): For now pass this request through the mediaengine to the
 776 // voice and video engines to do the real work. Once the capturer refactoring
 777 // is done, we will access the capturer using the ssrc (similar to how the
 778 // renderer is accessed today) and register with it directly.
 779 bool ChannelManager::RegisterVideoProcessor(VideoCapturer* capturer,
 780                                             VideoProcessor* processor) {
 781   return initialized_ && worker_thread_->Invoke<bool>(
 782       Bind(&ChannelManager::RegisterVideoProcessor_w, this,
 783            capturer, processor));
 784 }
 785
 786 bool ChannelManager::RegisterVideoProcessor_w(VideoCapturer* capturer,
 787                                               VideoProcessor* processor) {
 788   return capture_manager_->AddVideoProcessor(capturer, processor);
 789 }
 790
 791 bool ChannelManager::UnregisterVideoProcessor(VideoCapturer* capturer,
 792                                               VideoProcessor* processor) {
 793   return initialized_ && worker_thread_->Invoke<bool>(
 794       Bind(&ChannelManager::UnregisterVideoProcessor_w, this,
 795            capturer, processor));
 796 }
 797
 798 bool ChannelManager::UnregisterVideoProcessor_w(VideoCapturer* capturer,
 799                                                 VideoProcessor* processor) {
 800   return capture_manager_->RemoveVideoProcessor(capturer, processor);
 801 }
 802
 803 bool ChannelManager::RegisterVoiceProcessor(
 804     uint32 ssrc,
 805     VoiceProcessor* processor,
 806     MediaProcessorDirection direction) {
 807   return initialized_ && worker_thread_->Invoke<bool>(
 808       Bind(&MediaEngineInterface::RegisterVoiceProcessor, media_engine_.get(),
 809            ssrc, processor, direction));
 810 }
 811
 812 bool ChannelManager::UnregisterVoiceProcessor(
 813     uint32 ssrc,
 814     VoiceProcessor* processor,
 815     MediaProcessorDirection direction) {
 816   return initialized_ && worker_thread_->Invoke<bool>(
 817       Bind(&MediaEngineInterface::UnregisterVoiceProcessor,
 818            media_engine_.get(), ssrc, processor, direction));
 819 }
 820
 821 // The following are done in the new "CaptureManager" style that
 822 // all local video capturers, processors, and managers should move
 823 // to.
 824 // TODO(pthatcher): Add more of the CaptureManager interface.
 825 bool ChannelManager::StartVideoCapture(
 826     VideoCapturer* capturer, const VideoFormat& video_format) {
 827   return initialized_ && worker_thread_->Invoke<bool>(
 828       Bind(&CaptureManager::StartVideoCapture,
 829            capture_manager_.get(), capturer, video_format));
 830 }
 831
 832 bool ChannelManager::MuteToBlackThenPause(
 833     VideoCapturer* video_capturer, bool muted) {
 834   if (!initialized_) {
 835     return false;
 836   }
 837   worker_thread_->Invoke<void>(
 838       Bind(&VideoCapturer::MuteToBlackThenPause, video_capturer, muted));
 839   return true;
 840 }
 841
 842 bool ChannelManager::StopVideoCapture(
 843     VideoCapturer* capturer, const VideoFormat& video_format) {
 844   return initialized_ && worker_thread_->Invoke<bool>(
 845       Bind(&CaptureManager::StopVideoCapture,
 846            capture_manager_.get(), capturer, video_format));
 847 }
 848
 849 bool ChannelManager::RestartVideoCapture(
 850     VideoCapturer* video_capturer,
 851     const VideoFormat& previous_format,
 852     const VideoFormat& desired_format,
 853     CaptureManager::RestartOptions options) {
 854   return initialized_ && worker_thread_->Invoke<bool>(
 855       Bind(&CaptureManager::RestartVideoCapture, capture_manager_.get(),
 856            video_capturer, previous_format, desired_format, options));
 857 }
 858
 859 bool ChannelManager::AddVideoRenderer(
 860     VideoCapturer* capturer, VideoRenderer* renderer) {
 861   return initialized_ && worker_thread_->Invoke<bool>(
 862       Bind(&CaptureManager::AddVideoRenderer,
 863            capture_manager_.get(), capturer, renderer));
 864 }
 865
 866 bool ChannelManager::RemoveVideoRenderer(
 867     VideoCapturer* capturer, VideoRenderer* renderer) {
 868   return initialized_ && worker_thread_->Invoke<bool>(
 869       Bind(&CaptureManager::RemoveVideoRenderer,
 870            capture_manager_.get(), capturer, renderer));
 871 }
 872
 873 bool ChannelManager::IsScreencastRunning() const {
 874   return initialized_ && worker_thread_->Invoke<bool>(
 875       Bind(&ChannelManager::IsScreencastRunning_w, this));
 876 }
 877
 878 bool ChannelManager::IsScreencastRunning_w() const {
 879   VideoChannels::const_iterator it = video_channels_.begin();
 880   for ( ; it != video_channels_.end(); ++it) {
 881     if ((*it) && (*it)->IsScreencasting()) {
 882       return true;
 883     }
 884   }
 885   return false;
 886 }
 887
 888 void ChannelManager::OnVideoCaptureStateChange(VideoCapturer* capturer,
 889                                                CaptureState result) {
 890   // TODO(whyuan): Check capturer and signal failure only for camera video, not
 891   // screencast.
 892   capturing_ = result == CS_RUNNING;
 893   main_thread_->Post(this, MSG_VIDEOCAPTURESTATE,
 894                      new CaptureStateParams(capturer, result));
 895 }
 896
 897 void ChannelManager::OnMessage(rtc::Message* message) {
 898   switch (message->message_id) {
 899     case MSG_VIDEOCAPTURESTATE: {
 900       CaptureStateParams* data =
 901           static_cast<CaptureStateParams*>(message->pdata);
 902       SignalVideoCaptureStateChange(data->capturer, data->state);
 903       delete data;
 904       break;
 905     }
 906   }
 907 }
 908
 909
 910 static void GetDeviceNames(const std::vector<Device>& devs,
 911                            std::vector<std::string>* names) {
 912   names->clear();
 913   for (size_t i = 0; i < devs.size(); ++i) {
 914     names->push_back(devs[i].name);
 915   }
 916 }
 917
 918 bool ChannelManager::GetAudioInputDevices(std::vector<std::string>* names) {
 919   names->clear();
 920   std::vector<Device> devs;
 921   bool ret = device_manager_->GetAudioInputDevices(&devs);
 922   if (ret)
 923     GetDeviceNames(devs, names);
 924
 925   return ret;
 926 }
 927
 928 bool ChannelManager::GetAudioOutputDevices(std::vector<std::string>* names) {
 929   names->clear();
 930   std::vector<Device> devs;
 931   bool ret = device_manager_->GetAudioOutputDevices(&devs);
 932   if (ret)
 933     GetDeviceNames(devs, names);
 934
 935   return ret;
 936 }
 937
 938 bool ChannelManager::GetVideoCaptureDevices(std::vector<std::string>* names) {
 939   names->clear();
 940   std::vector<Device> devs;
 941   bool ret = device_manager_->GetVideoCaptureDevices(&devs);
 942   if (ret)
 943     GetDeviceNames(devs, names);
 944
 945   return ret;
 946 }
 947
 948 void ChannelManager::SetVideoCaptureDeviceMaxFormat(
 949     const std::string& usb_id,
 950     const VideoFormat& max_format) {
 951   device_manager_->SetVideoCaptureDeviceMaxFormat(usb_id, max_format);
 952 }
 953
 954 VideoFormat ChannelManager::GetStartCaptureFormat() {
 955   return worker_thread_->Invoke<VideoFormat>(
 956       Bind(&MediaEngineInterface::GetStartCaptureFormat, media_engine_.get()));
 957 }
 958
 959 bool ChannelManager::StartAecDump(rtc::PlatformFile file) {
 960   return worker_thread_->Invoke<bool>(
 961       Bind(&MediaEngineInterface::StartAecDump, media_engine_.get(), file));
 962 }
 963
 964 }  // namespace cricket