blob: 33d7ee37a9f3c92ad4e3e1c6af55583603e10762 [file] [log] [blame]
deadbeef6979b022015-09-24 16:47:53 -07001/*
kjellanderb24317b2016-02-10 07:54:43 -08002 * Copyright 2015 The WebRTC project authors. All Rights Reserved.
deadbeef6979b022015-09-24 16:47:53 -07003 *
kjellanderb24317b2016-02-10 07:54:43 -08004 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
deadbeef6979b022015-09-24 16:47:53 -07009 */
10
Henrik Kjellander15583c12016-02-10 10:53:12 +010011#include "webrtc/api/rtpsender.h"
deadbeef6979b022015-09-24 16:47:53 -070012
Henrik Kjellander15583c12016-02-10 10:53:12 +010013#include "webrtc/api/localaudiosource.h"
perkj9e083d22016-03-20 09:38:40 -070014#include "webrtc/api/mediastreaminterface.h"
deadbeeffac06552015-11-25 11:26:01 -080015#include "webrtc/base/helpers.h"
Peter Boströmdabc9442016-04-11 11:45:14 +020016#include "webrtc/base/trace_event.h"
deadbeef70ab1a12015-09-28 16:53:55 -070017
18namespace webrtc {
19
20LocalAudioSinkAdapter::LocalAudioSinkAdapter() : sink_(nullptr) {}
21
22LocalAudioSinkAdapter::~LocalAudioSinkAdapter() {
23 rtc::CritScope lock(&lock_);
24 if (sink_)
25 sink_->OnClose();
26}
27
28void LocalAudioSinkAdapter::OnData(const void* audio_data,
29 int bits_per_sample,
30 int sample_rate,
Peter Kasting69558702016-01-12 16:26:35 -080031 size_t number_of_channels,
deadbeef70ab1a12015-09-28 16:53:55 -070032 size_t number_of_frames) {
33 rtc::CritScope lock(&lock_);
34 if (sink_) {
35 sink_->OnData(audio_data, bits_per_sample, sample_rate, number_of_channels,
36 number_of_frames);
37 }
38}
39
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -080040void LocalAudioSinkAdapter::SetSink(cricket::AudioSource::Sink* sink) {
deadbeef70ab1a12015-09-28 16:53:55 -070041 rtc::CritScope lock(&lock_);
42 ASSERT(!sink || !sink_);
43 sink_ = sink;
44}
45
46AudioRtpSender::AudioRtpSender(AudioTrackInterface* track,
deadbeeffac06552015-11-25 11:26:01 -080047 const std::string& stream_id,
48 AudioProviderInterface* provider,
49 StatsCollector* stats)
deadbeef70ab1a12015-09-28 16:53:55 -070050 : id_(track->id()),
deadbeeffac06552015-11-25 11:26:01 -080051 stream_id_(stream_id),
deadbeef5def7b92015-11-20 11:43:22 -080052 provider_(provider),
deadbeeffac06552015-11-25 11:26:01 -080053 stats_(stats),
54 track_(track),
deadbeef70ab1a12015-09-28 16:53:55 -070055 cached_track_enabled_(track->enabled()),
56 sink_adapter_(new LocalAudioSinkAdapter()) {
deadbeeffac06552015-11-25 11:26:01 -080057 RTC_DCHECK(provider != nullptr);
deadbeef70ab1a12015-09-28 16:53:55 -070058 track_->RegisterObserver(this);
59 track_->AddSink(sink_adapter_.get());
deadbeef70ab1a12015-09-28 16:53:55 -070060}
61
deadbeefe1f9d832016-01-14 15:35:42 -080062AudioRtpSender::AudioRtpSender(AudioTrackInterface* track,
63 AudioProviderInterface* provider,
64 StatsCollector* stats)
65 : id_(track->id()),
66 stream_id_(rtc::CreateRandomUuid()),
67 provider_(provider),
68 stats_(stats),
69 track_(track),
70 cached_track_enabled_(track->enabled()),
71 sink_adapter_(new LocalAudioSinkAdapter()) {
72 RTC_DCHECK(provider != nullptr);
73 track_->RegisterObserver(this);
74 track_->AddSink(sink_adapter_.get());
75}
76
deadbeeffac06552015-11-25 11:26:01 -080077AudioRtpSender::AudioRtpSender(AudioProviderInterface* provider,
78 StatsCollector* stats)
79 : id_(rtc::CreateRandomUuid()),
80 stream_id_(rtc::CreateRandomUuid()),
81 provider_(provider),
82 stats_(stats),
83 sink_adapter_(new LocalAudioSinkAdapter()) {}
84
deadbeef70ab1a12015-09-28 16:53:55 -070085AudioRtpSender::~AudioRtpSender() {
deadbeef70ab1a12015-09-28 16:53:55 -070086 Stop();
87}
88
89void AudioRtpSender::OnChanged() {
Peter Boströmdabc9442016-04-11 11:45:14 +020090 TRACE_EVENT0("webrtc", "AudioRtpSender::OnChanged");
deadbeeffac06552015-11-25 11:26:01 -080091 RTC_DCHECK(!stopped_);
deadbeef70ab1a12015-09-28 16:53:55 -070092 if (cached_track_enabled_ != track_->enabled()) {
93 cached_track_enabled_ = track_->enabled();
deadbeeffac06552015-11-25 11:26:01 -080094 if (can_send_track()) {
95 SetAudioSend();
96 }
deadbeef70ab1a12015-09-28 16:53:55 -070097 }
98}
99
100bool AudioRtpSender::SetTrack(MediaStreamTrackInterface* track) {
Peter Boströmdabc9442016-04-11 11:45:14 +0200101 TRACE_EVENT0("webrtc", "AudioRtpSender::SetTrack");
deadbeeffac06552015-11-25 11:26:01 -0800102 if (stopped_) {
103 LOG(LS_ERROR) << "SetTrack can't be called on a stopped RtpSender.";
104 return false;
105 }
106 if (track && track->kind() != MediaStreamTrackInterface::kAudioKind) {
deadbeef70ab1a12015-09-28 16:53:55 -0700107 LOG(LS_ERROR) << "SetTrack called on audio RtpSender with " << track->kind()
108 << " track.";
109 return false;
110 }
111 AudioTrackInterface* audio_track = static_cast<AudioTrackInterface*>(track);
112
113 // Detach from old track.
deadbeeffac06552015-11-25 11:26:01 -0800114 if (track_) {
115 track_->RemoveSink(sink_adapter_.get());
116 track_->UnregisterObserver(this);
117 }
118
119 if (can_send_track() && stats_) {
120 stats_->RemoveLocalAudioTrack(track_.get(), ssrc_);
121 }
deadbeef70ab1a12015-09-28 16:53:55 -0700122
123 // Attach to new track.
deadbeeffac06552015-11-25 11:26:01 -0800124 bool prev_can_send_track = can_send_track();
deadbeef5dd42fd2016-05-02 16:20:01 -0700125 // Keep a reference to the old track to keep it alive until we call
126 // SetAudioSend.
127 rtc::scoped_refptr<AudioTrackInterface> old_track = track_;
deadbeef70ab1a12015-09-28 16:53:55 -0700128 track_ = audio_track;
deadbeeffac06552015-11-25 11:26:01 -0800129 if (track_) {
130 cached_track_enabled_ = track_->enabled();
131 track_->RegisterObserver(this);
132 track_->AddSink(sink_adapter_.get());
133 }
134
135 // Update audio provider.
136 if (can_send_track()) {
137 SetAudioSend();
138 if (stats_) {
139 stats_->AddLocalAudioTrack(track_.get(), ssrc_);
140 }
141 } else if (prev_can_send_track) {
142 cricket::AudioOptions options;
143 provider_->SetAudioSend(ssrc_, false, options, nullptr);
144 }
deadbeef70ab1a12015-09-28 16:53:55 -0700145 return true;
146}
147
deadbeeffac06552015-11-25 11:26:01 -0800148void AudioRtpSender::SetSsrc(uint32_t ssrc) {
Peter Boströmdabc9442016-04-11 11:45:14 +0200149 TRACE_EVENT0("webrtc", "AudioRtpSender::SetSsrc");
deadbeeffac06552015-11-25 11:26:01 -0800150 if (stopped_ || ssrc == ssrc_) {
151 return;
152 }
153 // If we are already sending with a particular SSRC, stop sending.
154 if (can_send_track()) {
155 cricket::AudioOptions options;
156 provider_->SetAudioSend(ssrc_, false, options, nullptr);
157 if (stats_) {
158 stats_->RemoveLocalAudioTrack(track_.get(), ssrc_);
159 }
160 }
161 ssrc_ = ssrc;
162 if (can_send_track()) {
163 SetAudioSend();
164 if (stats_) {
165 stats_->AddLocalAudioTrack(track_.get(), ssrc_);
166 }
167 }
168}
169
deadbeef70ab1a12015-09-28 16:53:55 -0700170void AudioRtpSender::Stop() {
Peter Boströmdabc9442016-04-11 11:45:14 +0200171 TRACE_EVENT0("webrtc", "AudioRtpSender::Stop");
deadbeef70ab1a12015-09-28 16:53:55 -0700172 // TODO(deadbeef): Need to do more here to fully stop sending packets.
deadbeeffac06552015-11-25 11:26:01 -0800173 if (stopped_) {
deadbeef70ab1a12015-09-28 16:53:55 -0700174 return;
175 }
deadbeeffac06552015-11-25 11:26:01 -0800176 if (track_) {
177 track_->RemoveSink(sink_adapter_.get());
178 track_->UnregisterObserver(this);
179 }
180 if (can_send_track()) {
181 cricket::AudioOptions options;
182 provider_->SetAudioSend(ssrc_, false, options, nullptr);
183 if (stats_) {
184 stats_->RemoveLocalAudioTrack(track_.get(), ssrc_);
185 }
186 }
187 stopped_ = true;
deadbeef70ab1a12015-09-28 16:53:55 -0700188}
189
deadbeeffac06552015-11-25 11:26:01 -0800190void AudioRtpSender::SetAudioSend() {
191 RTC_DCHECK(!stopped_ && can_send_track());
deadbeef70ab1a12015-09-28 16:53:55 -0700192 cricket::AudioOptions options;
Tommi3c169782016-01-21 16:12:17 +0100193#if !defined(WEBRTC_CHROMIUM_BUILD)
194 // TODO(tommi): Remove this hack when we move CreateAudioSource out of
195 // PeerConnection. This is a bit of a strange way to apply local audio
196 // options since it is also applied to all streams/channels, local or remote.
tommi6eca7e32015-12-15 04:27:11 -0800197 if (track_->enabled() && track_->GetSource() &&
198 !track_->GetSource()->remote()) {
deadbeef70ab1a12015-09-28 16:53:55 -0700199 // TODO(xians): Remove this static_cast since we should be able to connect
deadbeeffac06552015-11-25 11:26:01 -0800200 // a remote audio track to a peer connection.
deadbeef70ab1a12015-09-28 16:53:55 -0700201 options = static_cast<LocalAudioSource*>(track_->GetSource())->options();
202 }
Tommi3c169782016-01-21 16:12:17 +0100203#endif
deadbeef70ab1a12015-09-28 16:53:55 -0700204
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -0800205 cricket::AudioSource* source = sink_adapter_.get();
206 ASSERT(source != nullptr);
207 provider_->SetAudioSend(ssrc_, track_->enabled(), options, source);
deadbeef70ab1a12015-09-28 16:53:55 -0700208}
209
skvladdc1c62c2016-03-16 19:07:43 -0700210RtpParameters AudioRtpSender::GetParameters() const {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700211 return provider_->GetAudioRtpSendParameters(ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -0700212}
213
214bool AudioRtpSender::SetParameters(const RtpParameters& parameters) {
Peter Boströmdabc9442016-04-11 11:45:14 +0200215 TRACE_EVENT0("webrtc", "AudioRtpSender::SetParameters");
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700216 return provider_->SetAudioRtpSendParameters(ssrc_, parameters);
skvladdc1c62c2016-03-16 19:07:43 -0700217}
218
deadbeef70ab1a12015-09-28 16:53:55 -0700219VideoRtpSender::VideoRtpSender(VideoTrackInterface* track,
deadbeeffac06552015-11-25 11:26:01 -0800220 const std::string& stream_id,
deadbeef70ab1a12015-09-28 16:53:55 -0700221 VideoProviderInterface* provider)
222 : id_(track->id()),
deadbeeffac06552015-11-25 11:26:01 -0800223 stream_id_(stream_id),
deadbeef5def7b92015-11-20 11:43:22 -0800224 provider_(provider),
deadbeeffac06552015-11-25 11:26:01 -0800225 track_(track),
deadbeef70ab1a12015-09-28 16:53:55 -0700226 cached_track_enabled_(track->enabled()) {
deadbeeffac06552015-11-25 11:26:01 -0800227 RTC_DCHECK(provider != nullptr);
deadbeef70ab1a12015-09-28 16:53:55 -0700228 track_->RegisterObserver(this);
deadbeef70ab1a12015-09-28 16:53:55 -0700229}
230
deadbeefe1f9d832016-01-14 15:35:42 -0800231VideoRtpSender::VideoRtpSender(VideoTrackInterface* track,
232 VideoProviderInterface* provider)
233 : id_(track->id()),
234 stream_id_(rtc::CreateRandomUuid()),
235 provider_(provider),
236 track_(track),
237 cached_track_enabled_(track->enabled()) {
238 RTC_DCHECK(provider != nullptr);
239 track_->RegisterObserver(this);
240}
241
deadbeeffac06552015-11-25 11:26:01 -0800242VideoRtpSender::VideoRtpSender(VideoProviderInterface* provider)
243 : id_(rtc::CreateRandomUuid()),
244 stream_id_(rtc::CreateRandomUuid()),
245 provider_(provider) {}
246
deadbeef70ab1a12015-09-28 16:53:55 -0700247VideoRtpSender::~VideoRtpSender() {
deadbeef70ab1a12015-09-28 16:53:55 -0700248 Stop();
249}
250
251void VideoRtpSender::OnChanged() {
Peter Boströmdabc9442016-04-11 11:45:14 +0200252 TRACE_EVENT0("webrtc", "VideoRtpSender::OnChanged");
deadbeeffac06552015-11-25 11:26:01 -0800253 RTC_DCHECK(!stopped_);
deadbeef70ab1a12015-09-28 16:53:55 -0700254 if (cached_track_enabled_ != track_->enabled()) {
255 cached_track_enabled_ = track_->enabled();
deadbeeffac06552015-11-25 11:26:01 -0800256 if (can_send_track()) {
257 SetVideoSend();
258 }
deadbeef70ab1a12015-09-28 16:53:55 -0700259 }
260}
261
262bool VideoRtpSender::SetTrack(MediaStreamTrackInterface* track) {
Peter Boströmdabc9442016-04-11 11:45:14 +0200263 TRACE_EVENT0("webrtc", "VideoRtpSender::SetTrack");
deadbeeffac06552015-11-25 11:26:01 -0800264 if (stopped_) {
265 LOG(LS_ERROR) << "SetTrack can't be called on a stopped RtpSender.";
266 return false;
267 }
268 if (track && track->kind() != MediaStreamTrackInterface::kVideoKind) {
deadbeef70ab1a12015-09-28 16:53:55 -0700269 LOG(LS_ERROR) << "SetTrack called on video RtpSender with " << track->kind()
270 << " track.";
271 return false;
272 }
273 VideoTrackInterface* video_track = static_cast<VideoTrackInterface*>(track);
274
275 // Detach from old track.
deadbeeffac06552015-11-25 11:26:01 -0800276 if (track_) {
277 track_->UnregisterObserver(this);
278 }
deadbeef70ab1a12015-09-28 16:53:55 -0700279
280 // Attach to new track.
deadbeeffac06552015-11-25 11:26:01 -0800281 bool prev_can_send_track = can_send_track();
deadbeef5dd42fd2016-05-02 16:20:01 -0700282 // Keep a reference to the old track to keep it alive until we call
deadbeef5a4a75a2016-06-02 16:23:38 -0700283 // SetVideoSend.
deadbeef5dd42fd2016-05-02 16:20:01 -0700284 rtc::scoped_refptr<VideoTrackInterface> old_track = track_;
deadbeef70ab1a12015-09-28 16:53:55 -0700285 track_ = video_track;
deadbeeffac06552015-11-25 11:26:01 -0800286 if (track_) {
287 cached_track_enabled_ = track_->enabled();
288 track_->RegisterObserver(this);
289 }
290
291 // Update video provider.
292 if (can_send_track()) {
deadbeeffac06552015-11-25 11:26:01 -0800293 SetVideoSend();
294 } else if (prev_can_send_track) {
deadbeef5a4a75a2016-06-02 16:23:38 -0700295 ClearVideoSend();
deadbeeffac06552015-11-25 11:26:01 -0800296 }
deadbeef70ab1a12015-09-28 16:53:55 -0700297 return true;
298}
299
deadbeeffac06552015-11-25 11:26:01 -0800300void VideoRtpSender::SetSsrc(uint32_t ssrc) {
Peter Boströmdabc9442016-04-11 11:45:14 +0200301 TRACE_EVENT0("webrtc", "VideoRtpSender::SetSsrc");
deadbeeffac06552015-11-25 11:26:01 -0800302 if (stopped_ || ssrc == ssrc_) {
303 return;
304 }
305 // If we are already sending with a particular SSRC, stop sending.
306 if (can_send_track()) {
deadbeef5a4a75a2016-06-02 16:23:38 -0700307 ClearVideoSend();
deadbeeffac06552015-11-25 11:26:01 -0800308 }
309 ssrc_ = ssrc;
310 if (can_send_track()) {
deadbeeffac06552015-11-25 11:26:01 -0800311 SetVideoSend();
312 }
313}
314
deadbeef70ab1a12015-09-28 16:53:55 -0700315void VideoRtpSender::Stop() {
Peter Boströmdabc9442016-04-11 11:45:14 +0200316 TRACE_EVENT0("webrtc", "VideoRtpSender::Stop");
deadbeef70ab1a12015-09-28 16:53:55 -0700317 // TODO(deadbeef): Need to do more here to fully stop sending packets.
deadbeeffac06552015-11-25 11:26:01 -0800318 if (stopped_) {
deadbeef70ab1a12015-09-28 16:53:55 -0700319 return;
320 }
deadbeeffac06552015-11-25 11:26:01 -0800321 if (track_) {
322 track_->UnregisterObserver(this);
323 }
324 if (can_send_track()) {
deadbeef5a4a75a2016-06-02 16:23:38 -0700325 ClearVideoSend();
deadbeeffac06552015-11-25 11:26:01 -0800326 }
327 stopped_ = true;
deadbeef70ab1a12015-09-28 16:53:55 -0700328}
329
deadbeeffac06552015-11-25 11:26:01 -0800330void VideoRtpSender::SetVideoSend() {
331 RTC_DCHECK(!stopped_ && can_send_track());
perkj0d3eef22016-03-09 02:39:17 +0100332 cricket::VideoOptions options;
perkja3ede6c2016-03-08 01:27:48 +0100333 VideoTrackSourceInterface* source = track_->GetSource();
perkj0d3eef22016-03-09 02:39:17 +0100334 if (source) {
335 options.is_screencast = rtc::Optional<bool>(source->is_screencast());
Perc0d31e92016-03-31 17:23:39 +0200336 options.video_noise_reduction = source->needs_denoising();
deadbeef70ab1a12015-09-28 16:53:55 -0700337 }
deadbeef5a4a75a2016-06-02 16:23:38 -0700338 provider_->SetVideoSend(ssrc_, track_->enabled(), &options, track_);
339}
340
341void VideoRtpSender::ClearVideoSend() {
342 RTC_DCHECK(ssrc_ != 0);
343 RTC_DCHECK(provider_ != nullptr);
344 provider_->SetVideoSend(ssrc_, false, nullptr, nullptr);
deadbeef70ab1a12015-09-28 16:53:55 -0700345}
346
skvladdc1c62c2016-03-16 19:07:43 -0700347RtpParameters VideoRtpSender::GetParameters() const {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700348 return provider_->GetVideoRtpSendParameters(ssrc_);
skvladdc1c62c2016-03-16 19:07:43 -0700349}
350
351bool VideoRtpSender::SetParameters(const RtpParameters& parameters) {
Peter Boströmdabc9442016-04-11 11:45:14 +0200352 TRACE_EVENT0("webrtc", "VideoRtpSender::SetParameters");
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700353 return provider_->SetVideoRtpSendParameters(ssrc_, parameters);
skvladdc1c62c2016-03-16 19:07:43 -0700354}
355
deadbeef70ab1a12015-09-28 16:53:55 -0700356} // namespace webrtc