#include "talk/app/webrtc/mediaconstraintsinterface.h"
#include "talk/app/webrtc/mediastreamhandler.h"
#include "talk/app/webrtc/streamcollection.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
#include "talk/p2p/client/basicportallocator.h"
#include "talk/session/media/channelmanager.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
namespace {
MSG_GETSTATS,
};
-struct SetSessionDescriptionMsg : public talk_base::MessageData {
+struct SetSessionDescriptionMsg : public rtc::MessageData {
explicit SetSessionDescriptionMsg(
webrtc::SetSessionDescriptionObserver* observer)
: observer(observer) {
}
- talk_base::scoped_refptr<webrtc::SetSessionDescriptionObserver> observer;
+ rtc::scoped_refptr<webrtc::SetSessionDescriptionObserver> observer;
std::string error;
};
-struct GetStatsMsg : public talk_base::MessageData {
+struct GetStatsMsg : public rtc::MessageData {
explicit GetStatsMsg(webrtc::StatsObserver* observer)
: observer(observer) {
}
webrtc::StatsReports reports;
- talk_base::scoped_refptr<webrtc::StatsObserver> observer;
+ rtc::scoped_refptr<webrtc::StatsObserver> observer;
};
// |in_str| should be of format
*host = in_str.substr(1, closebracket - 1);
std::string::size_type colonpos = in_str.find(':', closebracket);
if (std::string::npos != colonpos) {
- if (!talk_base::FromString(
+ if (!rtc::FromString(
in_str.substr(closebracket + 2, std::string::npos), port)) {
return false;
}
std::string::size_type colonpos = in_str.find(':');
if (std::string::npos != colonpos) {
*host = in_str.substr(0, colonpos);
- if (!talk_base::FromString(
+ if (!rtc::FromString(
in_str.substr(colonpos + 1, std::string::npos), port)) {
return false;
}
}
std::vector<std::string> tokens;
std::string turn_transport_type = kUdpTransportType;
- talk_base::tokenize(server.uri, '?', &tokens);
+ rtc::tokenize(server.uri, '?', &tokens);
std::string uri_without_transport = tokens[0];
// Let's look into transport= param, if it exists.
if (tokens.size() == kTurnTransportTokensNum) { // ?transport= is present.
std::string uri_transport_param = tokens[1];
- talk_base::tokenize(uri_transport_param, '=', &tokens);
+ rtc::tokenize(uri_transport_param, '=', &tokens);
if (tokens[0] == kTransport) {
// As per above grammar transport param will be consist of lower case
// letters.
// Let's break hostname.
tokens.clear();
- talk_base::tokenize(hoststring, '@', &tokens);
+ rtc::tokenize(hoststring, '@', &tokens);
hoststring = tokens[0];
if (tokens.size() == kTurnHostTokensNum) {
- server.username = talk_base::s_url_decode(tokens[0]);
+ server.username = rtc::s_url_decode(tokens[0]);
hoststring = tokens[1];
}
if (server.username.empty()) {
// Turn url example from the spec |url:"turn:user@turn.example.org"|.
std::vector<std::string> turn_tokens;
- talk_base::tokenize(address, '@', &turn_tokens);
+ rtc::tokenize(address, '@', &turn_tokens);
if (turn_tokens.size() == kTurnHostTokensNum) {
- server.username = talk_base::s_url_decode(turn_tokens[0]);
+ server.username = rtc::s_url_decode(turn_tokens[0]);
address = turn_tokens[1];
}
}
mediastream_signaling_.get()));
stream_handler_container_.reset(new MediaStreamHandlerContainer(
session_.get(), session_.get()));
- stats_.set_session(session_.get());
+ stats_.reset(new StatsCollector(session_.get()));
// Initialize the WebRtcSession. It creates transport channels etc.
if (!session_->Initialize(factory_->options(), constraints,
return true;
}
-talk_base::scoped_refptr<StreamCollectionInterface>
+rtc::scoped_refptr<StreamCollectionInterface>
PeerConnection::local_streams() {
return mediastream_signaling_->local_streams();
}
-talk_base::scoped_refptr<StreamCollectionInterface>
+rtc::scoped_refptr<StreamCollectionInterface>
PeerConnection::remote_streams() {
return mediastream_signaling_->remote_streams();
}
if (!mediastream_signaling_->AddLocalStream(local_stream)) {
return false;
}
- stats_.AddStream(local_stream);
+ stats_->AddStream(local_stream);
observer_->OnRenegotiationNeeded();
return true;
}
observer_->OnRenegotiationNeeded();
}
-talk_base::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
+rtc::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
AudioTrackInterface* track) {
if (!track) {
LOG(LS_ERROR) << "CreateDtmfSender - track is NULL.";
return NULL;
}
- talk_base::scoped_refptr<DtmfSenderInterface> sender(
+ rtc::scoped_refptr<DtmfSenderInterface> sender(
DtmfSender::Create(track, signaling_thread(), session_.get()));
if (!sender.get()) {
LOG(LS_ERROR) << "CreateDtmfSender failed on DtmfSender::Create.";
return false;
}
- stats_.UpdateStats(level);
- talk_base::scoped_ptr<GetStatsMsg> msg(new GetStatsMsg(observer));
- if (!stats_.GetStats(track, &(msg->reports))) {
+ stats_->UpdateStats(level);
+ rtc::scoped_ptr<GetStatsMsg> msg(new GetStatsMsg(observer));
+ if (!stats_->GetStats(track, &(msg->reports))) {
return false;
}
signaling_thread()->Post(this, MSG_GETSTATS, msg.release());
return ice_gathering_state_;
}
-talk_base::scoped_refptr<DataChannelInterface>
+rtc::scoped_refptr<DataChannelInterface>
PeerConnection::CreateDataChannel(
const std::string& label,
const DataChannelInit* config) {
bool first_datachannel = !mediastream_signaling_->HasDataChannels();
- talk_base::scoped_ptr<InternalDataChannelInit> internal_config;
+ rtc::scoped_ptr<InternalDataChannelInit> internal_config;
if (config) {
internal_config.reset(new InternalDataChannelInit(*config));
}
- talk_base::scoped_refptr<DataChannelInterface> channel(
+ rtc::scoped_refptr<DataChannelInterface> channel(
session_->CreateDataChannel(label, internal_config.get()));
if (!channel.get())
return NULL;
LOG(LS_ERROR) << "CreateOffer - observer is NULL.";
return;
}
- session_->CreateOffer(observer, constraints);
+ RTCOfferAnswerOptions options;
+ // Defaults to receiving audio and not receiving video.
+ options.offer_to_receive_audio =
+ RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
+ options.offer_to_receive_video = 0;
+
+ bool value;
+ size_t mandatory_constraints = 0;
+
+ if (FindConstraint(constraints,
+ MediaConstraintsInterface::kOfferToReceiveAudio,
+ &value,
+ &mandatory_constraints)) {
+ options.offer_to_receive_audio =
+ value ? RTCOfferAnswerOptions::kOfferToReceiveMediaTrue : 0;
+ }
+
+ if (FindConstraint(constraints,
+ MediaConstraintsInterface::kOfferToReceiveVideo,
+ &value,
+ &mandatory_constraints)) {
+ options.offer_to_receive_video =
+ value ? RTCOfferAnswerOptions::kOfferToReceiveMediaTrue : 0;
+ }
+
+ if (FindConstraint(constraints,
+ MediaConstraintsInterface::kVoiceActivityDetection,
+ &value,
+ &mandatory_constraints)) {
+ options.voice_activity_detection = value;
+ }
+
+ if (FindConstraint(constraints,
+ MediaConstraintsInterface::kIceRestart,
+ &value,
+ &mandatory_constraints)) {
+ options.ice_restart = value;
+ }
+
+ if (FindConstraint(constraints,
+ MediaConstraintsInterface::kUseRtpMux,
+ &value,
+ &mandatory_constraints)) {
+ options.use_rtp_mux = value;
+ }
+
+ CreateOffer(observer, options);
+}
+
+void PeerConnection::CreateOffer(CreateSessionDescriptionObserver* observer,
+ const RTCOfferAnswerOptions& options) {
+ if (!VERIFY(observer != NULL)) {
+ LOG(LS_ERROR) << "CreateOffer - observer is NULL.";
+ return;
+ }
+ session_->CreateOffer(observer, options);
}
void PeerConnection::CreateAnswer(
}
// Update stats here so that we have the most recent stats for tracks and
// streams that might be removed by updating the session description.
- stats_.UpdateStats(kStatsOutputLevelStandard);
+ stats_->UpdateStats(kStatsOutputLevelStandard);
std::string error;
if (!session_->SetLocalDescription(desc, &error)) {
PostSetSessionDescriptionFailure(observer, error);
}
// Update stats here so that we have the most recent stats for tracks and
// streams that might be removed by updating the session description.
- stats_.UpdateStats(kStatsOutputLevelStandard);
+ stats_->UpdateStats(kStatsOutputLevelStandard);
std::string error;
if (!session_->SetRemoteDescription(desc, &error)) {
PostSetSessionDescriptionFailure(observer, error);
return false;
}
- std::vector<talk_base::SocketAddress> stun_hosts;
+ std::vector<rtc::SocketAddress> stun_hosts;
typedef std::vector<StunConfiguration>::const_iterator StunIt;
for (StunIt stun_it = stuns.begin(); stun_it != stuns.end(); ++stun_it) {
stun_hosts.push_back(stun_it->server);
}
- talk_base::SocketAddress stun_addr;
+ rtc::SocketAddress stun_addr;
if (!stun_hosts.empty()) {
stun_addr = stun_hosts.front();
LOG(LS_INFO) << "UpdateIce: StunServer Address: " << stun_addr.ToString();
void PeerConnection::Close() {
// Update stats here so that we have the most recent stats for tracks and
// streams before the channels are closed.
- stats_.UpdateStats(kStatsOutputLevelStandard);
+ stats_->UpdateStats(kStatsOutputLevelStandard);
session_->Terminate();
}
}
}
-void PeerConnection::OnMessage(talk_base::Message* msg) {
+void PeerConnection::OnMessage(rtc::Message* msg) {
switch (msg->message_id) {
case MSG_SET_SESSIONDESCRIPTION_SUCCESS: {
SetSessionDescriptionMsg* param =
}
void PeerConnection::OnAddRemoteStream(MediaStreamInterface* stream) {
- stats_.AddStream(stream);
+ stats_->AddStream(stream);
observer_->OnAddStream(stream);
}
AudioTrackInterface* audio_track,
uint32 ssrc) {
stream_handler_container_->AddLocalAudioTrack(stream, audio_track, ssrc);
- stats_.AddLocalAudioTrack(audio_track, ssrc);
+ stats_->AddLocalAudioTrack(audio_track, ssrc);
}
void PeerConnection::OnAddLocalVideoTrack(MediaStreamInterface* stream,
VideoTrackInterface* video_track,
AudioTrackInterface* audio_track,
uint32 ssrc) {
stream_handler_container_->RemoveLocalTrack(stream, audio_track);
- stats_.RemoveLocalAudioTrack(audio_track, ssrc);
+ stats_->RemoveLocalAudioTrack(audio_track, ssrc);
}
void PeerConnection::OnRemoveLocalVideoTrack(MediaStreamInterface* stream,
projects / platform / framework / web / crosswalk.git / blobdiff