Home | History | Annotate | Download | only in webrtc 
      1 /*
      2  * libjingle
      3  * Copyright 2012, 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/app/webrtc/mediastreamhandler.h"
     29 
     30 #include "talk/app/webrtc/localaudiosource.h"
     31 #include "talk/app/webrtc/localvideosource.h"
     32 #include "talk/app/webrtc/videosourceinterface.h"
     33 
     34 namespace webrtc {
     35 
     36 TrackHandler::TrackHandler(MediaStreamTrackInterface* track, uint32 ssrc)
     37     : track_(track),
     38       ssrc_(ssrc),
     39       state_(track->state()),
     40       enabled_(track->enabled()) {
     41   track_->RegisterObserver(this);
     42 }
     43 
     44 TrackHandler::~TrackHandler() {
     45   track_->UnregisterObserver(this);
     46 }
     47 
     48 void TrackHandler::OnChanged() {
     49   if (state_ != track_->state()) {
     50     state_ = track_->state();
     51     OnStateChanged();
     52   }
     53   if (enabled_ != track_->enabled()) {
     54     enabled_ = track_->enabled();
     55     OnEnabledChanged();
     56   }
     57 }
     58 
     59 LocalAudioTrackHandler::LocalAudioTrackHandler(
     60     AudioTrackInterface* track,
     61     uint32 ssrc,
     62     AudioProviderInterface* provider)
     63     : TrackHandler(track, ssrc),
     64       audio_track_(track),
     65       provider_(provider) {
     66   OnEnabledChanged();
     67 }
     68 
     69 LocalAudioTrackHandler::~LocalAudioTrackHandler() {
     70 }
     71 
     72 void LocalAudioTrackHandler::OnStateChanged() {
     73   // TODO(perkj): What should happen when the state change?
     74 }
     75 
     76 void LocalAudioTrackHandler::Stop() {
     77   cricket::AudioOptions options;
     78   provider_->SetAudioSend(ssrc(), false, options, NULL);
     79 }
     80 
     81 void LocalAudioTrackHandler::OnEnabledChanged() {
     82   cricket::AudioOptions options;
     83   if (audio_track_->enabled() && audio_track_->GetSource()) {
     84     options = static_cast<LocalAudioSource*>(
     85         audio_track_->GetSource())->options();
     86   }
     87   provider_->SetAudioSend(ssrc(), audio_track_->enabled(), options,
     88                           audio_track_->GetRenderer());
     89 }
     90 
     91 RemoteAudioTrackHandler::RemoteAudioTrackHandler(
     92     AudioTrackInterface* track,
     93     uint32 ssrc,
     94     AudioProviderInterface* provider)
     95     : TrackHandler(track, ssrc),
     96       audio_track_(track),
     97       provider_(provider) {
     98   OnEnabledChanged();
     99 }
    100 
    101 RemoteAudioTrackHandler::~RemoteAudioTrackHandler() {
    102 }
    103 
    104 void RemoteAudioTrackHandler::Stop() {
    105   provider_->SetAudioPlayout(ssrc(), false, NULL);
    106 }
    107 
    108 void RemoteAudioTrackHandler::OnStateChanged() {
    109 }
    110 
    111 void RemoteAudioTrackHandler::OnEnabledChanged() {
    112   provider_->SetAudioPlayout(ssrc(), audio_track_->enabled(),
    113                              audio_track_->GetRenderer());
    114 }
    115 
    116 LocalVideoTrackHandler::LocalVideoTrackHandler(
    117     VideoTrackInterface* track,
    118     uint32 ssrc,
    119     VideoProviderInterface* provider)
    120     : TrackHandler(track, ssrc),
    121       local_video_track_(track),
    122       provider_(provider) {
    123   VideoSourceInterface* source = local_video_track_->GetSource();
    124   if (source)
    125     provider_->SetCaptureDevice(ssrc, source->GetVideoCapturer());
    126   OnEnabledChanged();
    127 }
    128 
    129 LocalVideoTrackHandler::~LocalVideoTrackHandler() {
    130 }
    131 
    132 void LocalVideoTrackHandler::OnStateChanged() {
    133 }
    134 
    135 void LocalVideoTrackHandler::Stop() {
    136   provider_->SetCaptureDevice(ssrc(), NULL);
    137   provider_->SetVideoSend(ssrc(), false, NULL);
    138 }
    139 
    140 void LocalVideoTrackHandler::OnEnabledChanged() {
    141   const cricket::VideoOptions* options = NULL;
    142   VideoSourceInterface* source = local_video_track_->GetSource();
    143   if (local_video_track_->enabled() && source) {
    144     options = source->options();
    145   }
    146   provider_->SetVideoSend(ssrc(), local_video_track_->enabled(), options);
    147 }
    148 
    149 RemoteVideoTrackHandler::RemoteVideoTrackHandler(
    150     VideoTrackInterface* track,
    151     uint32 ssrc,
    152     VideoProviderInterface* provider)
    153     : TrackHandler(track, ssrc),
    154       remote_video_track_(track),
    155       provider_(provider) {
    156   OnEnabledChanged();
    157 }
    158 
    159 RemoteVideoTrackHandler::~RemoteVideoTrackHandler() {
    160 }
    161 
    162 void RemoteVideoTrackHandler::Stop() {
    163   // Since cricket::VideoRenderer is not reference counted
    164   // we need to remove the renderer before we are deleted.
    165   provider_->SetVideoPlayout(ssrc(), false, NULL);
    166 }
    167 
    168 void RemoteVideoTrackHandler::OnStateChanged() {
    169 }
    170 
    171 void RemoteVideoTrackHandler::OnEnabledChanged() {
    172   provider_->SetVideoPlayout(ssrc(),
    173                              remote_video_track_->enabled(),
    174                              remote_video_track_->FrameInput());
    175 }
    176 
    177 MediaStreamHandler::MediaStreamHandler(MediaStreamInterface* stream,
    178                                        AudioProviderInterface* audio_provider,
    179                                        VideoProviderInterface* video_provider)
    180     : stream_(stream),
    181       audio_provider_(audio_provider),
    182       video_provider_(video_provider) {
    183 }
    184 
    185 MediaStreamHandler::~MediaStreamHandler() {
    186   for (TrackHandlers::iterator it = track_handlers_.begin();
    187        it != track_handlers_.end(); ++it) {
    188     delete *it;
    189   }
    190 }
    191 
    192 void MediaStreamHandler::RemoveTrack(MediaStreamTrackInterface* track) {
    193   for (TrackHandlers::iterator it = track_handlers_.begin();
    194        it != track_handlers_.end(); ++it) {
    195     if ((*it)->track() == track) {
    196       TrackHandler* track = *it;
    197       track->Stop();
    198       delete track;
    199       track_handlers_.erase(it);
    200       break;
    201     }
    202   }
    203 }
    204 
    205 TrackHandler* MediaStreamHandler::FindTrackHandler(
    206     MediaStreamTrackInterface* track) {
    207   TrackHandlers::iterator it = track_handlers_.begin();
    208   for (; it != track_handlers_.end(); ++it) {
    209     if ((*it)->track() == track) {
    210       return *it;
    211       break;
    212     }
    213   }
    214   return NULL;
    215 }
    216 
    217 MediaStreamInterface* MediaStreamHandler::stream() {
    218   return stream_.get();
    219 }
    220 
    221 void MediaStreamHandler::OnChanged() {
    222 }
    223 
    224 void MediaStreamHandler::Stop() {
    225   for (TrackHandlers::const_iterator it = track_handlers_.begin();
    226       it != track_handlers_.end(); ++it) {
    227     (*it)->Stop();
    228   }
    229 }
    230 
    231 LocalMediaStreamHandler::LocalMediaStreamHandler(
    232     MediaStreamInterface* stream,
    233     AudioProviderInterface* audio_provider,
    234     VideoProviderInterface* video_provider)
    235     : MediaStreamHandler(stream, audio_provider, video_provider) {
    236 }
    237 
    238 LocalMediaStreamHandler::~LocalMediaStreamHandler() {
    239 }
    240 
    241 void LocalMediaStreamHandler::AddAudioTrack(AudioTrackInterface* audio_track,
    242                                             uint32 ssrc) {
    243   ASSERT(!FindTrackHandler(audio_track));
    244 
    245   TrackHandler* handler(new LocalAudioTrackHandler(audio_track, ssrc,
    246                                                    audio_provider_));
    247   track_handlers_.push_back(handler);
    248 }
    249 
    250 void LocalMediaStreamHandler::AddVideoTrack(VideoTrackInterface* video_track,
    251                                             uint32 ssrc) {
    252   ASSERT(!FindTrackHandler(video_track));
    253 
    254   TrackHandler* handler(new LocalVideoTrackHandler(video_track, ssrc,
    255                                                    video_provider_));
    256   track_handlers_.push_back(handler);
    257 }
    258 
    259 RemoteMediaStreamHandler::RemoteMediaStreamHandler(
    260     MediaStreamInterface* stream,
    261     AudioProviderInterface* audio_provider,
    262     VideoProviderInterface* video_provider)
    263     : MediaStreamHandler(stream, audio_provider, video_provider) {
    264 }
    265 
    266 RemoteMediaStreamHandler::~RemoteMediaStreamHandler() {
    267 }
    268 
    269 void RemoteMediaStreamHandler::AddAudioTrack(AudioTrackInterface* audio_track,
    270                                              uint32 ssrc) {
    271   ASSERT(!FindTrackHandler(audio_track));
    272   TrackHandler* handler(
    273       new RemoteAudioTrackHandler(audio_track, ssrc, audio_provider_));
    274   track_handlers_.push_back(handler);
    275 }
    276 
    277 void RemoteMediaStreamHandler::AddVideoTrack(VideoTrackInterface* video_track,
    278                                              uint32 ssrc) {
    279   ASSERT(!FindTrackHandler(video_track));
    280   TrackHandler* handler(
    281       new RemoteVideoTrackHandler(video_track, ssrc, video_provider_));
    282   track_handlers_.push_back(handler);
    283 }
    284 
    285 MediaStreamHandlerContainer::MediaStreamHandlerContainer(
    286     AudioProviderInterface* audio_provider,
    287     VideoProviderInterface* video_provider)
    288     : audio_provider_(audio_provider),
    289       video_provider_(video_provider) {
    290 }
    291 
    292 MediaStreamHandlerContainer::~MediaStreamHandlerContainer() {
    293   ASSERT(remote_streams_handlers_.empty());
    294   ASSERT(local_streams_handlers_.empty());
    295 }
    296 
    297 void MediaStreamHandlerContainer::TearDown() {
    298   for (StreamHandlerList::iterator it = remote_streams_handlers_.begin();
    299        it != remote_streams_handlers_.end(); ++it) {
    300     (*it)->Stop();
    301     delete *it;
    302   }
    303   remote_streams_handlers_.clear();
    304   for (StreamHandlerList::iterator it = local_streams_handlers_.begin();
    305        it != local_streams_handlers_.end(); ++it) {
    306     (*it)->Stop();
    307     delete *it;
    308   }
    309   local_streams_handlers_.clear();
    310 }
    311 
    312 void MediaStreamHandlerContainer::RemoveRemoteStream(
    313     MediaStreamInterface* stream) {
    314   DeleteStreamHandler(&remote_streams_handlers_, stream);
    315 }
    316 
    317 void MediaStreamHandlerContainer::AddRemoteAudioTrack(
    318     MediaStreamInterface* stream,
    319     AudioTrackInterface* audio_track,
    320     uint32 ssrc) {
    321   MediaStreamHandler* handler = FindStreamHandler(remote_streams_handlers_,
    322                                                   stream);
    323   if (handler == NULL) {
    324     handler = CreateRemoteStreamHandler(stream);
    325   }
    326   handler->AddAudioTrack(audio_track, ssrc);
    327 }
    328 
    329 void MediaStreamHandlerContainer::AddRemoteVideoTrack(
    330     MediaStreamInterface* stream,
    331     VideoTrackInterface* video_track,
    332     uint32 ssrc) {
    333   MediaStreamHandler* handler = FindStreamHandler(remote_streams_handlers_,
    334                                                   stream);
    335   if (handler == NULL) {
    336     handler = CreateRemoteStreamHandler(stream);
    337   }
    338   handler->AddVideoTrack(video_track, ssrc);
    339 }
    340 
    341 void MediaStreamHandlerContainer::RemoveRemoteTrack(
    342     MediaStreamInterface* stream,
    343     MediaStreamTrackInterface* track) {
    344   MediaStreamHandler* handler = FindStreamHandler(remote_streams_handlers_,
    345                                                   stream);
    346   if (!VERIFY(handler != NULL)) {
    347     LOG(LS_WARNING) << "Local MediaStreamHandler for stream  with id "
    348                     << stream->label() << "doesnt't exist.";
    349     return;
    350   }
    351   handler->RemoveTrack(track);
    352 }
    353 
    354 void MediaStreamHandlerContainer::RemoveLocalStream(
    355     MediaStreamInterface* stream) {
    356   DeleteStreamHandler(&local_streams_handlers_, stream);
    357 }
    358 
    359 void MediaStreamHandlerContainer::AddLocalAudioTrack(
    360     MediaStreamInterface* stream,
    361     AudioTrackInterface* audio_track,
    362     uint32 ssrc) {
    363   MediaStreamHandler* handler = FindStreamHandler(local_streams_handlers_,
    364                                                   stream);
    365   if (handler == NULL) {
    366     handler = CreateLocalStreamHandler(stream);
    367   }
    368   handler->AddAudioTrack(audio_track, ssrc);
    369 }
    370 
    371 void MediaStreamHandlerContainer::AddLocalVideoTrack(
    372     MediaStreamInterface* stream,
    373     VideoTrackInterface* video_track,
    374     uint32 ssrc) {
    375   MediaStreamHandler* handler = FindStreamHandler(local_streams_handlers_,
    376                                                   stream);
    377   if (handler == NULL) {
    378     handler = CreateLocalStreamHandler(stream);
    379   }
    380   handler->AddVideoTrack(video_track, ssrc);
    381 }
    382 
    383 void MediaStreamHandlerContainer::RemoveLocalTrack(
    384     MediaStreamInterface* stream,
    385     MediaStreamTrackInterface* track) {
    386   MediaStreamHandler* handler = FindStreamHandler(local_streams_handlers_,
    387                                                   stream);
    388   if (!VERIFY(handler != NULL)) {
    389     LOG(LS_WARNING) << "Remote MediaStreamHandler for stream with id "
    390                     << stream->label() << "doesnt't exist.";
    391     return;
    392   }
    393   handler->RemoveTrack(track);
    394 }
    395 
    396 MediaStreamHandler* MediaStreamHandlerContainer::CreateRemoteStreamHandler(
    397     MediaStreamInterface* stream) {
    398   ASSERT(!FindStreamHandler(remote_streams_handlers_, stream));
    399 
    400   RemoteMediaStreamHandler* handler =
    401       new RemoteMediaStreamHandler(stream, audio_provider_, video_provider_);
    402   remote_streams_handlers_.push_back(handler);
    403   return handler;
    404 }
    405 
    406 MediaStreamHandler* MediaStreamHandlerContainer::CreateLocalStreamHandler(
    407     MediaStreamInterface* stream) {
    408   ASSERT(!FindStreamHandler(local_streams_handlers_, stream));
    409 
    410   LocalMediaStreamHandler* handler =
    411       new LocalMediaStreamHandler(stream, audio_provider_, video_provider_);
    412   local_streams_handlers_.push_back(handler);
    413   return handler;
    414 }
    415 
    416 MediaStreamHandler* MediaStreamHandlerContainer::FindStreamHandler(
    417     const StreamHandlerList& handlers,
    418     MediaStreamInterface* stream) {
    419   StreamHandlerList::const_iterator it = handlers.begin();
    420   for (; it != handlers.end(); ++it) {
    421     if ((*it)->stream() == stream) {
    422       return *it;
    423     }
    424   }
    425   return NULL;
    426 }
    427 
    428 void MediaStreamHandlerContainer::DeleteStreamHandler(
    429     StreamHandlerList* streamhandlers, MediaStreamInterface* stream) {
    430   StreamHandlerList::iterator it = streamhandlers->begin();
    431   for (; it != streamhandlers->end(); ++it) {
    432     if ((*it)->stream() == stream) {
    433       (*it)->Stop();
    434       delete *it;
    435       streamhandlers->erase(it);
    436       break;
    437     }
    438   }
    439 }
    440 
    441 }  // namespace webrtc
    442