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