← Back to branch summary

~ubuntu-branches/debian/experimental/kopete/experimental

« back to all changes in this revision

Viewing changes to protocols/jabber/googletalk/libjingle/talk/app/webrtc/mediastreamtrackproxy.cc

  • Committer: Package Import Robot
  • Author(s): Maximiliano Curia
  • Date: 2015-02-24 11:32:57 UTC
  • mfrom: (1.1.41 vivid)
  • Revision ID: package-import@ubuntu.com-20150224113257-gnupg4v7lzz18ij0
Tags: 4:14.12.2-1
* New upstream release (14.12.2).
* Bump Standards-Version to 3.9.6, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
protocols/jabber/googletalk/libjingle/talk/app/webrtc/mediastreamtrackproxy.cc
1
 
/*
2
 
 * libjingle
3
 
 * Copyright 2011, 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/mediastreamtrackproxy.h"
29
 
 
30
 
#include "talk/session/phone/videocapturer.h"
31
 
 
32
 
namespace {
33
 
 
34
 
enum {
35
 
  MSG_REGISTER_OBSERVER = 1,
36
 
  MSG_UNREGISTER_OBSERVER,
37
 
  MSG_LABEL,
38
 
  MSG_ENABLED,
39
 
  MSG_SET_ENABLED,
40
 
  MSG_STATE,
41
 
  MSG_GET_AUDIODEVICE,
42
 
  MSG_GET_VIDEODEVICE,
43
 
  MSG_GET_VIDEORENDERER,
44
 
  MSG_SET_VIDEORENDERER,
45
 
};
46
 
 
47
 
typedef talk_base::TypedMessageData<std::string*> LabelMessageData;
48
 
typedef talk_base::TypedMessageData<webrtc::ObserverInterface*>
49
 
    ObserverMessageData;
50
 
typedef talk_base::TypedMessageData
51
 
    <webrtc::MediaStreamTrackInterface::TrackState> TrackStateMessageData;
52
 
typedef talk_base::TypedMessageData<bool> EnableMessageData;
53
 
 
54
 
 
55
 
class AudioDeviceMessageData : public talk_base::MessageData {
56
 
 public:
57
 
  talk_base::scoped_refptr<webrtc::AudioDeviceModule> audio_device_;
58
 
};
59
 
 
60
 
class VideoDeviceMessageData : public talk_base::MessageData {
61
 
 public:
62
 
  cricket::VideoCapturer* video_device_;
63
 
};
64
 
 
65
 
class VideoRendererMessageData : public talk_base::MessageData {
66
 
 public:
67
 
  talk_base::scoped_refptr<webrtc::VideoRendererWrapperInterface>
68
 
      video_renderer_;
69
 
};
70
 
 
71
 
}  // namespace anonymous
72
 
 
73
 
namespace webrtc {
74
 
 
75
 
template <class T>
76
 
MediaStreamTrackProxy<T>::MediaStreamTrackProxy(
77
 
    talk_base::Thread* signaling_thread)
78
 
    : signaling_thread_(signaling_thread) {
79
 
}
80
 
 
81
 
template <class T>
82
 
void MediaStreamTrackProxy<T>::Init(MediaStreamTrackInterface* track) {
83
 
  track_ = track;
84
 
}
85
 
 
86
 
template <class T>
87
 
std::string MediaStreamTrackProxy<T>::kind() const {
88
 
  return track_->kind();
89
 
}
90
 
 
91
 
template <class T>
92
 
std::string MediaStreamTrackProxy<T>::label() const {
93
 
  if (!signaling_thread_->IsCurrent()) {
94
 
    std::string label;
95
 
    LabelMessageData msg(&label);
96
 
    Send(MSG_LABEL, &msg);
97
 
    return label;
98
 
  }
99
 
  return track_->label();
100
 
}
101
 
 
102
 
template <class T>
103
 
MediaStreamTrackInterface::TrackState MediaStreamTrackProxy<T>::state() const {
104
 
  if (!signaling_thread_->IsCurrent()) {
105
 
    TrackStateMessageData msg(MediaStreamTrackInterface::kInitializing);
106
 
    Send(MSG_STATE, &msg);
107
 
    return msg.data();
108
 
  }
109
 
  return track_->state();
110
 
}
111
 
 
112
 
template <class T>
113
 
bool MediaStreamTrackProxy<T>::enabled() const {
114
 
  if (!signaling_thread_->IsCurrent()) {
115
 
    EnableMessageData msg(false);
116
 
    Send(MSG_ENABLED, &msg);
117
 
    return msg.data();
118
 
  }
119
 
  return track_->enabled();
120
 
}
121
 
 
122
 
template <class T>
123
 
bool MediaStreamTrackProxy<T>::set_enabled(bool enable) {
124
 
  if (!signaling_thread_->IsCurrent()) {
125
 
    EnableMessageData msg(enable);
126
 
    Send(MSG_SET_ENABLED, &msg);
127
 
    return msg.data();
128
 
  }
129
 
  return track_->set_enabled(enable);
130
 
}
131
 
 
132
 
template <class T>
133
 
bool MediaStreamTrackProxy<T>::set_state(
134
 
    MediaStreamTrackInterface::TrackState new_state) {
135
 
  if (!signaling_thread_->IsCurrent()) {
136
 
    // State should only be allowed to be changed from the signaling thread.
137
 
    ASSERT(!"Not Allowed!");
138
 
    return false;
139
 
  }
140
 
  return track_->set_state(new_state);
141
 
}
142
 
 
143
 
template <class T>
144
 
void MediaStreamTrackProxy<T>::RegisterObserver(ObserverInterface* observer) {
145
 
  if (!signaling_thread_->IsCurrent()) {
146
 
    ObserverMessageData msg(observer);
147
 
    Send(MSG_REGISTER_OBSERVER, &msg);
148
 
    return;
149
 
  }
150
 
  track_->RegisterObserver(observer);
151
 
}
152
 
 
153
 
template <class T>
154
 
void MediaStreamTrackProxy<T>::UnregisterObserver(ObserverInterface* observer) {
155
 
  if (!signaling_thread_->IsCurrent()) {
156
 
    ObserverMessageData msg(observer);
157
 
    Send(MSG_UNREGISTER_OBSERVER, &msg);
158
 
    return;
159
 
  }
160
 
  track_->UnregisterObserver(observer);
161
 
}
162
 
 
163
 
template <class T>
164
 
void MediaStreamTrackProxy<T>::Send(uint32 id,
165
 
                                    talk_base::MessageData* data) const {
166
 
  signaling_thread_->Send(const_cast<MediaStreamTrackProxy<T>*>(this), id,
167
 
                          data);
168
 
}
169
 
 
170
 
template <class T>
171
 
bool MediaStreamTrackProxy<T>::HandleMessage(talk_base::Message* msg) {
172
 
  talk_base::MessageData* data = msg->pdata;
173
 
  switch (msg->message_id) {
174
 
    case MSG_REGISTER_OBSERVER: {
175
 
      ObserverMessageData* observer = static_cast<ObserverMessageData*>(data);
176
 
      track_->RegisterObserver(observer->data());
177
 
      return true;
178
 
      break;
179
 
    }
180
 
    case MSG_UNREGISTER_OBSERVER: {
181
 
      ObserverMessageData* observer = static_cast<ObserverMessageData*>(data);
182
 
      track_->UnregisterObserver(observer->data());
183
 
      return true;
184
 
      break;
185
 
    }
186
 
    case MSG_LABEL: {
187
 
      LabelMessageData* label = static_cast<LabelMessageData*>(data);
188
 
      *(label->data()) = track_->label();
189
 
      return true;
190
 
    }
191
 
    case MSG_SET_ENABLED: {
192
 
      EnableMessageData* enabled = static_cast<EnableMessageData*>(data);
193
 
      enabled->data() = track_->set_enabled(enabled->data());
194
 
      return true;
195
 
      break;
196
 
    }
197
 
    case MSG_ENABLED: {
198
 
      EnableMessageData* enabled = static_cast<EnableMessageData*>(data);
199
 
      enabled->data() = track_->enabled();
200
 
      return true;
201
 
      break;
202
 
    }
203
 
    case MSG_STATE: {
204
 
      TrackStateMessageData* state = static_cast<TrackStateMessageData*>(data);
205
 
      state->data() = track_->state();
206
 
      return true;
207
 
      break;
208
 
    }
209
 
    default:
210
 
      return false;
211
 
  }
212
 
}
213
 
 
214
 
AudioTrackProxy::AudioTrackProxy(const std::string& label,
215
 
                                 talk_base::Thread* signaling_thread)
216
 
    : MediaStreamTrackProxy<LocalAudioTrackInterface>(signaling_thread),
217
 
      audio_track_(AudioTrack::CreateRemote(label)) {
218
 
  Init(audio_track_);
219
 
}
220
 
 
221
 
AudioTrackProxy::AudioTrackProxy(const std::string& label,
222
 
                                 AudioDeviceModule* audio_device,
223
 
                                 talk_base::Thread* signaling_thread)
224
 
    : MediaStreamTrackProxy<LocalAudioTrackInterface>(signaling_thread),
225
 
      audio_track_(AudioTrack::CreateLocal(label, audio_device)) {
226
 
  Init(audio_track_);
227
 
}
228
 
 
229
 
AudioTrackProxy::AudioTrackProxy(LocalAudioTrackInterface* implementation,
230
 
                                 talk_base::Thread* signaling_thread)
231
 
    : MediaStreamTrackProxy<LocalAudioTrackInterface>(signaling_thread),
232
 
      audio_track_(implementation) {
233
 
  Init(audio_track_);
234
 
}
235
 
 
236
 
talk_base::scoped_refptr<AudioTrackInterface> AudioTrackProxy::CreateRemote(
237
 
    const std::string& label,
238
 
    talk_base::Thread* signaling_thread) {
239
 
  ASSERT(signaling_thread != NULL);
240
 
  talk_base::RefCountedObject<AudioTrackProxy>* track =
241
 
      new talk_base::RefCountedObject<AudioTrackProxy>(label, signaling_thread);
242
 
  return track;
243
 
}
244
 
 
245
 
talk_base::scoped_refptr<LocalAudioTrackInterface> AudioTrackProxy::CreateLocal(
246
 
    const std::string& label,
247
 
    AudioDeviceModule* audio_device,
248
 
    talk_base::Thread* signaling_thread) {
249
 
  ASSERT(signaling_thread != NULL);
250
 
  talk_base::RefCountedObject<AudioTrackProxy>* track =
251
 
      new talk_base::RefCountedObject<AudioTrackProxy>(label,
252
 
                                               audio_device,
253
 
                                               signaling_thread);
254
 
  return track;
255
 
}
256
 
 
257
 
talk_base::scoped_refptr<LocalAudioTrackInterface> AudioTrackProxy::CreateLocal(
258
 
    LocalAudioTrackInterface* implementation,
259
 
    talk_base::Thread* signaling_thread) {
260
 
  ASSERT(signaling_thread != NULL);
261
 
  talk_base::RefCountedObject<AudioTrackProxy>* track =
262
 
      new talk_base::RefCountedObject<AudioTrackProxy>(implementation,
263
 
                                               signaling_thread);
264
 
  return track;
265
 
}
266
 
 
267
 
AudioDeviceModule* AudioTrackProxy::GetAudioDevice() {
268
 
  if (!signaling_thread_->IsCurrent()) {
269
 
    AudioDeviceMessageData msg;
270
 
    Send(MSG_GET_AUDIODEVICE, &msg);
271
 
    return msg.audio_device_;
272
 
  }
273
 
  return audio_track_->GetAudioDevice();
274
 
}
275
 
 
276
 
void AudioTrackProxy::OnMessage(talk_base::Message* msg) {
277
 
  if (!MediaStreamTrackProxy<LocalAudioTrackInterface>::HandleMessage(msg)) {
278
 
    if (msg->message_id == MSG_GET_AUDIODEVICE) {
279
 
      AudioDeviceMessageData* audio_device =
280
 
          static_cast<AudioDeviceMessageData*>(msg->pdata);
281
 
      audio_device->audio_device_ = audio_track_->GetAudioDevice();
282
 
    } else {
283
 
      ASSERT(!"Not Implemented!");
284
 
    }
285
 
  }
286
 
}
287
 
 
288
 
VideoTrackProxy::VideoTrackProxy(const std::string& label,
289
 
                                 talk_base::Thread* signaling_thread)
290
 
    : MediaStreamTrackProxy<LocalVideoTrackInterface>(signaling_thread),
291
 
      video_track_(VideoTrack::CreateRemote(label)) {
292
 
  Init(video_track_);
293
 
}
294
 
 
295
 
VideoTrackProxy::VideoTrackProxy(const std::string& label,
296
 
                                 cricket::VideoCapturer* video_device,
297
 
                                 talk_base::Thread* signaling_thread)
298
 
    : MediaStreamTrackProxy<LocalVideoTrackInterface>(signaling_thread),
299
 
      video_track_(VideoTrack::CreateLocal(label, video_device)) {
300
 
  Init(video_track_);
301
 
}
302
 
 
303
 
VideoTrackProxy::VideoTrackProxy(LocalVideoTrackInterface* implementation,
304
 
                                 talk_base::Thread* signaling_thread)
305
 
    : MediaStreamTrackProxy<LocalVideoTrackInterface>(signaling_thread),
306
 
      video_track_(implementation) {
307
 
  Init(video_track_);
308
 
}
309
 
 
310
 
talk_base::scoped_refptr<VideoTrackInterface> VideoTrackProxy::CreateRemote(
311
 
    const std::string& label,
312
 
    talk_base::Thread* signaling_thread) {
313
 
  ASSERT(signaling_thread != NULL);
314
 
  talk_base::RefCountedObject<VideoTrackProxy>* track =
315
 
      new talk_base::RefCountedObject<VideoTrackProxy>(label, signaling_thread);
316
 
  return track;
317
 
}
318
 
 
319
 
talk_base::scoped_refptr<LocalVideoTrackInterface> VideoTrackProxy::CreateLocal(
320
 
    const std::string& label,
321
 
    cricket::VideoCapturer* video_device,
322
 
    talk_base::Thread* signaling_thread) {
323
 
  ASSERT(signaling_thread != NULL);
324
 
  talk_base::RefCountedObject<VideoTrackProxy>* track =
325
 
      new talk_base::RefCountedObject<VideoTrackProxy>(label, video_device,
326
 
                                                       signaling_thread);
327
 
  return track;
328
 
}
329
 
 
330
 
talk_base::scoped_refptr<LocalVideoTrackInterface> VideoTrackProxy::CreateLocal(
331
 
    LocalVideoTrackInterface* implementation,
332
 
    talk_base::Thread* signaling_thread) {
333
 
  ASSERT(signaling_thread != NULL);
334
 
  talk_base::RefCountedObject<VideoTrackProxy>* track =
335
 
      new talk_base::RefCountedObject<VideoTrackProxy>(implementation,
336
 
                                                       signaling_thread);
337
 
  return track;
338
 
}
339
 
 
340
 
cricket::VideoCapturer* VideoTrackProxy::GetVideoCapture() {
341
 
  if (!signaling_thread_->IsCurrent()) {
342
 
    VideoDeviceMessageData msg;
343
 
    Send(MSG_GET_VIDEODEVICE, &msg);
344
 
    return msg.video_device_;
345
 
  }
346
 
  return video_track_->GetVideoCapture();
347
 
}
348
 
 
349
 
void VideoTrackProxy::SetRenderer(VideoRendererWrapperInterface* renderer) {
350
 
  if (!signaling_thread_->IsCurrent()) {
351
 
    VideoRendererMessageData msg;
352
 
    msg.video_renderer_ = renderer;
353
 
    Send(MSG_SET_VIDEORENDERER, &msg);
354
 
    return;
355
 
  }
356
 
  return video_track_->SetRenderer(renderer);
357
 
}
358
 
 
359
 
VideoRendererWrapperInterface* VideoTrackProxy::GetRenderer() {
360
 
  if (!signaling_thread_->IsCurrent()) {
361
 
    VideoRendererMessageData msg;
362
 
    Send(MSG_GET_VIDEORENDERER, &msg);
363
 
    return msg.video_renderer_;
364
 
  }
365
 
  return video_track_->GetRenderer();
366
 
}
367
 
 
368
 
void VideoTrackProxy::OnMessage(talk_base::Message* msg) {
369
 
  if (!MediaStreamTrackProxy<LocalVideoTrackInterface>::HandleMessage(msg)) {
370
 
    switch (msg->message_id) {
371
 
      case  MSG_GET_VIDEODEVICE: {
372
 
        VideoDeviceMessageData* video_device =
373
 
            static_cast<VideoDeviceMessageData*>(msg->pdata);
374
 
        video_device->video_device_ = video_track_->GetVideoCapture();
375
 
        break;
376
 
      }
377
 
      case MSG_GET_VIDEORENDERER: {
378
 
        VideoRendererMessageData* video_renderer =
379
 
            static_cast<VideoRendererMessageData*>(msg->pdata);
380
 
        video_renderer->video_renderer_ = video_track_->GetRenderer();
381
 
        break;
382
 
      }
383
 
      case MSG_SET_VIDEORENDERER: {
384
 
        VideoRendererMessageData* video_renderer =
385
 
            static_cast<VideoRendererMessageData*>(msg->pdata);
386
 
        video_track_->SetRenderer(video_renderer->video_renderer_.get());
387
 
        break;
388
 
      }
389
 
    default:
390
 
      ASSERT(!"Not Implemented!");
391
 
      break;
392
 
    }
393
 
  }
394
 
}
395
 
 
396
 
}  // namespace webrtc