blob: 801648dc047bf11720c4460cc7d8f6a6824fd425 [file] [log] [blame]
/*
* libjingle
* Copyright 2012 Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// This file contains classes for listening on changes on MediaStreams and
// MediaTracks that are connected to a certain PeerConnection.
// Example: If a user sets a rendererer on a remote video track the renderer is
// connected to the appropriate remote video stream.
#ifndef TALK_APP_WEBRTC_MEDIASTREAMHANDLER_H_
#define TALK_APP_WEBRTC_MEDIASTREAMHANDLER_H_
#include <list>
#include <vector>
#include "talk/app/webrtc/mediastreaminterface.h"
#include "talk/app/webrtc/mediastreamprovider.h"
#include "talk/app/webrtc/peerconnectioninterface.h"
#include "talk/media/base/audiorenderer.h"
#include "webrtc/base/thread.h"
namespace webrtc {
// TrackHandler listen to events on a MediaStreamTrackInterface that is
// connected to a certain PeerConnection.
class TrackHandler : public ObserverInterface {
public:
TrackHandler(MediaStreamTrackInterface* track, uint32 ssrc);
virtual ~TrackHandler();
virtual void OnChanged();
// Stop using |track_| on this PeerConnection.
virtual void Stop() = 0;
MediaStreamTrackInterface* track() { return track_; }
uint32 ssrc() const { return ssrc_; }
protected:
virtual void OnStateChanged() = 0;
virtual void OnEnabledChanged() = 0;
private:
rtc::scoped_refptr<MediaStreamTrackInterface> track_;
uint32 ssrc_;
MediaStreamTrackInterface::TrackState state_;
bool enabled_;
};
// LocalAudioSinkAdapter receives data callback as a sink to the local
// AudioTrack, and passes the data to the sink of AudioRenderer.
class LocalAudioSinkAdapter : public AudioTrackSinkInterface,
public cricket::AudioRenderer {
public:
LocalAudioSinkAdapter();
virtual ~LocalAudioSinkAdapter();
private:
// AudioSinkInterface implementation.
void OnData(const void* audio_data,
int bits_per_sample,
int sample_rate,
int number_of_channels,
int number_of_frames) override;
// cricket::AudioRenderer implementation.
void SetSink(cricket::AudioRenderer::Sink* sink) override;
cricket::AudioRenderer::Sink* sink_;
// Critical section protecting |sink_|.
rtc::CriticalSection lock_;
};
// LocalAudioTrackHandler listen to events on a local AudioTrack instance
// connected to a PeerConnection and orders the |provider| to executes the
// requested change.
class LocalAudioTrackHandler : public TrackHandler {
public:
LocalAudioTrackHandler(AudioTrackInterface* track,
uint32 ssrc,
AudioProviderInterface* provider);
virtual ~LocalAudioTrackHandler();
void Stop() override;
protected:
void OnStateChanged() override;
void OnEnabledChanged() override;
private:
AudioTrackInterface* audio_track_;
AudioProviderInterface* provider_;
// Used to pass the data callback from the |audio_track_| to the other
// end of cricket::AudioRenderer.
rtc::scoped_ptr<LocalAudioSinkAdapter> sink_adapter_;
};
// RemoteAudioTrackHandler listen to events on a remote AudioTrack instance
// connected to a PeerConnection and orders the |provider| to executes the
// requested change.
class RemoteAudioTrackHandler : public AudioSourceInterface::AudioObserver,
public TrackHandler {
public:
RemoteAudioTrackHandler(AudioTrackInterface* track,
uint32 ssrc,
AudioProviderInterface* provider);
virtual ~RemoteAudioTrackHandler();
void Stop() override;
protected:
void OnStateChanged() override;
void OnEnabledChanged() override;
private:
// AudioSourceInterface::AudioObserver implementation.
void OnSetVolume(double volume) override;
AudioTrackInterface* audio_track_;
AudioProviderInterface* provider_;
};
// LocalVideoTrackHandler listen to events on a local VideoTrack instance
// connected to a PeerConnection and orders the |provider| to executes the
// requested change.
class LocalVideoTrackHandler : public TrackHandler {
public:
LocalVideoTrackHandler(VideoTrackInterface* track,
uint32 ssrc,
VideoProviderInterface* provider);
virtual ~LocalVideoTrackHandler();
void Stop() override;
protected:
void OnStateChanged() override;
void OnEnabledChanged() override;
private:
VideoTrackInterface* local_video_track_;
VideoProviderInterface* provider_;
};
// RemoteVideoTrackHandler listen to events on a remote VideoTrack instance
// connected to a PeerConnection and orders the |provider| to execute
// requested changes.
class RemoteVideoTrackHandler : public TrackHandler {
public:
RemoteVideoTrackHandler(VideoTrackInterface* track,
uint32 ssrc,
VideoProviderInterface* provider);
virtual ~RemoteVideoTrackHandler();
void Stop() override;
protected:
void OnStateChanged() override;
void OnEnabledChanged() override;
private:
VideoTrackInterface* remote_video_track_;
VideoProviderInterface* provider_;
};
class MediaStreamHandler : public ObserverInterface {
public:
MediaStreamHandler(MediaStreamInterface* stream,
AudioProviderInterface* audio_provider,
VideoProviderInterface* video_provider);
~MediaStreamHandler();
MediaStreamInterface* stream();
void Stop();
virtual void AddAudioTrack(AudioTrackInterface* audio_track, uint32 ssrc) = 0;
virtual void AddVideoTrack(VideoTrackInterface* video_track, uint32 ssrc) = 0;
virtual void RemoveTrack(MediaStreamTrackInterface* track);
void OnChanged() override;
protected:
TrackHandler* FindTrackHandler(MediaStreamTrackInterface* track);
rtc::scoped_refptr<MediaStreamInterface> stream_;
AudioProviderInterface* audio_provider_;
VideoProviderInterface* video_provider_;
typedef std::vector<TrackHandler*> TrackHandlers;
TrackHandlers track_handlers_;
};
class LocalMediaStreamHandler : public MediaStreamHandler {
public:
LocalMediaStreamHandler(MediaStreamInterface* stream,
AudioProviderInterface* audio_provider,
VideoProviderInterface* video_provider);
~LocalMediaStreamHandler();
void AddAudioTrack(AudioTrackInterface* audio_track, uint32 ssrc) override;
void AddVideoTrack(VideoTrackInterface* video_track, uint32 ssrc) override;
};
class RemoteMediaStreamHandler : public MediaStreamHandler {
public:
RemoteMediaStreamHandler(MediaStreamInterface* stream,
AudioProviderInterface* audio_provider,
VideoProviderInterface* video_provider);
~RemoteMediaStreamHandler();
void AddAudioTrack(AudioTrackInterface* audio_track, uint32 ssrc) override;
void AddVideoTrack(VideoTrackInterface* video_track, uint32 ssrc) override;
};
// Container for MediaStreamHandlers of currently known local and remote
// MediaStreams.
class MediaStreamHandlerContainer {
public:
MediaStreamHandlerContainer(AudioProviderInterface* audio_provider,
VideoProviderInterface* video_provider);
~MediaStreamHandlerContainer();
// Notify all referenced objects that MediaStreamHandlerContainer will be
// destroyed. This method must be called prior to the dtor and prior to the
// |audio_provider| and |video_provider| is destroyed.
void TearDown();
// Remove all TrackHandlers for tracks in |stream| and make sure
// the audio_provider and video_provider is notified that the tracks has been
// removed.
void RemoveRemoteStream(MediaStreamInterface* stream);
// Create a RemoteAudioTrackHandler and associate |audio_track| with |ssrc|.
void AddRemoteAudioTrack(MediaStreamInterface* stream,
AudioTrackInterface* audio_track,
uint32 ssrc);
// Create a RemoteVideoTrackHandler and associate |video_track| with |ssrc|.
void AddRemoteVideoTrack(MediaStreamInterface* stream,
VideoTrackInterface* video_track,
uint32 ssrc);
// Remove the TrackHandler for |track|.
void RemoveRemoteTrack(MediaStreamInterface* stream,
MediaStreamTrackInterface* track);
// Remove all TrackHandlers for tracks in |stream| and make sure
// the audio_provider and video_provider is notified that the tracks has been
// removed.
void RemoveLocalStream(MediaStreamInterface* stream);
// Create a LocalAudioTrackHandler and associate |audio_track| with |ssrc|.
void AddLocalAudioTrack(MediaStreamInterface* stream,
AudioTrackInterface* audio_track,
uint32 ssrc);
// Create a LocalVideoTrackHandler and associate |video_track| with |ssrc|.
void AddLocalVideoTrack(MediaStreamInterface* stream,
VideoTrackInterface* video_track,
uint32 ssrc);
// Remove the TrackHandler for |track|.
void RemoveLocalTrack(MediaStreamInterface* stream,
MediaStreamTrackInterface* track);
private:
typedef std::list<MediaStreamHandler*> StreamHandlerList;
MediaStreamHandler* FindStreamHandler(const StreamHandlerList& handlers,
MediaStreamInterface* stream);
MediaStreamHandler* CreateRemoteStreamHandler(MediaStreamInterface* stream);
MediaStreamHandler* CreateLocalStreamHandler(MediaStreamInterface* stream);
void DeleteStreamHandler(StreamHandlerList* streamhandlers,
MediaStreamInterface* stream);
StreamHandlerList local_streams_handlers_;
StreamHandlerList remote_streams_handlers_;
AudioProviderInterface* audio_provider_;
VideoProviderInterface* video_provider_;
};
} // namespace webrtc
#endif // TALK_APP_WEBRTC_MEDIASTREAMHANDLER_H_