| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * libjingle | |
| 3 * Copyright 2004 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 #ifndef TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_ | |
| 29 #define TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_ | |
| 30 | |
| 31 #include <list> | |
| 32 #include <map> | |
| 33 #include <set> | |
| 34 #include <string> | |
| 35 #include <vector> | |
| 36 | |
| 37 #include "talk/media/base/audiorenderer.h" | |
| 38 #include "talk/media/base/mediaengine.h" | |
| 39 #include "talk/media/base/rtputils.h" | |
| 40 #include "talk/media/base/streamparams.h" | |
| 41 #include "webrtc/audio/audio_sink.h" | |
| 42 #include "webrtc/base/buffer.h" | |
| 43 #include "webrtc/base/stringutils.h" | |
| 44 #include "webrtc/p2p/base/sessiondescription.h" | |
| 45 | |
| 46 namespace cricket { | |
| 47 | |
| 48 class FakeMediaEngine; | |
| 49 class FakeVideoEngine; | |
| 50 class FakeVoiceEngine; | |
| 51 | |
| 52 // A common helper class that handles sending and receiving RTP/RTCP packets. | |
| 53 template <class Base> class RtpHelper : public Base { | |
| 54 public: | |
| 55 RtpHelper() | |
| 56 : sending_(false), | |
| 57 playout_(false), | |
| 58 fail_set_send_codecs_(false), | |
| 59 fail_set_recv_codecs_(false), | |
| 60 send_ssrc_(0), | |
| 61 ready_to_send_(false) {} | |
| 62 const std::vector<RtpHeaderExtension>& recv_extensions() { | |
| 63 return recv_extensions_; | |
| 64 } | |
| 65 const std::vector<RtpHeaderExtension>& send_extensions() { | |
| 66 return send_extensions_; | |
| 67 } | |
| 68 bool sending() const { return sending_; } | |
| 69 bool playout() const { return playout_; } | |
| 70 const std::list<std::string>& rtp_packets() const { return rtp_packets_; } | |
| 71 const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; } | |
| 72 | |
| 73 bool SendRtp(const void* data, int len, const rtc::PacketOptions& options) { | |
| 74 if (!sending_) { | |
| 75 return false; | |
| 76 } | |
| 77 rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len, | |
| 78 kMaxRtpPacketLen); | |
| 79 return Base::SendPacket(&packet, options); | |
| 80 } | |
| 81 bool SendRtcp(const void* data, int len) { | |
| 82 rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len, | |
| 83 kMaxRtpPacketLen); | |
| 84 return Base::SendRtcp(&packet, rtc::PacketOptions()); | |
| 85 } | |
| 86 | |
| 87 bool CheckRtp(const void* data, int len) { | |
| 88 bool success = !rtp_packets_.empty(); | |
| 89 if (success) { | |
| 90 std::string packet = rtp_packets_.front(); | |
| 91 rtp_packets_.pop_front(); | |
| 92 success = (packet == std::string(static_cast<const char*>(data), len)); | |
| 93 } | |
| 94 return success; | |
| 95 } | |
| 96 bool CheckRtcp(const void* data, int len) { | |
| 97 bool success = !rtcp_packets_.empty(); | |
| 98 if (success) { | |
| 99 std::string packet = rtcp_packets_.front(); | |
| 100 rtcp_packets_.pop_front(); | |
| 101 success = (packet == std::string(static_cast<const char*>(data), len)); | |
| 102 } | |
| 103 return success; | |
| 104 } | |
| 105 bool CheckNoRtp() { return rtp_packets_.empty(); } | |
| 106 bool CheckNoRtcp() { return rtcp_packets_.empty(); } | |
| 107 void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; } | |
| 108 void set_fail_set_recv_codecs(bool fail) { fail_set_recv_codecs_ = fail; } | |
| 109 virtual bool AddSendStream(const StreamParams& sp) { | |
| 110 if (std::find(send_streams_.begin(), send_streams_.end(), sp) != | |
| 111 send_streams_.end()) { | |
| 112 return false; | |
| 113 } | |
| 114 send_streams_.push_back(sp); | |
| 115 return true; | |
| 116 } | |
| 117 virtual bool RemoveSendStream(uint32_t ssrc) { | |
| 118 return RemoveStreamBySsrc(&send_streams_, ssrc); | |
| 119 } | |
| 120 virtual bool AddRecvStream(const StreamParams& sp) { | |
| 121 if (std::find(receive_streams_.begin(), receive_streams_.end(), sp) != | |
| 122 receive_streams_.end()) { | |
| 123 return false; | |
| 124 } | |
| 125 receive_streams_.push_back(sp); | |
| 126 return true; | |
| 127 } | |
| 128 virtual bool RemoveRecvStream(uint32_t ssrc) { | |
| 129 return RemoveStreamBySsrc(&receive_streams_, ssrc); | |
| 130 } | |
| 131 bool IsStreamMuted(uint32_t ssrc) const { | |
| 132 bool ret = muted_streams_.find(ssrc) != muted_streams_.end(); | |
| 133 // If |ssrc = 0| check if the first send stream is muted. | |
| 134 if (!ret && ssrc == 0 && !send_streams_.empty()) { | |
| 135 return muted_streams_.find(send_streams_[0].first_ssrc()) != | |
| 136 muted_streams_.end(); | |
| 137 } | |
| 138 return ret; | |
| 139 } | |
| 140 const std::vector<StreamParams>& send_streams() const { | |
| 141 return send_streams_; | |
| 142 } | |
| 143 const std::vector<StreamParams>& recv_streams() const { | |
| 144 return receive_streams_; | |
| 145 } | |
| 146 bool HasRecvStream(uint32_t ssrc) const { | |
| 147 return GetStreamBySsrc(receive_streams_, ssrc) != nullptr; | |
| 148 } | |
| 149 bool HasSendStream(uint32_t ssrc) const { | |
| 150 return GetStreamBySsrc(send_streams_, ssrc) != nullptr; | |
| 151 } | |
| 152 // TODO(perkj): This is to support legacy unit test that only check one | |
| 153 // sending stream. | |
| 154 uint32_t send_ssrc() const { | |
| 155 if (send_streams_.empty()) | |
| 156 return 0; | |
| 157 return send_streams_[0].first_ssrc(); | |
| 158 } | |
| 159 | |
| 160 // TODO(perkj): This is to support legacy unit test that only check one | |
| 161 // sending stream. | |
| 162 const std::string rtcp_cname() { | |
| 163 if (send_streams_.empty()) | |
| 164 return ""; | |
| 165 return send_streams_[0].cname; | |
| 166 } | |
| 167 | |
| 168 bool ready_to_send() const { | |
| 169 return ready_to_send_; | |
| 170 } | |
| 171 | |
| 172 protected: | |
| 173 bool MuteStream(uint32_t ssrc, bool mute) { | |
| 174 if (!HasSendStream(ssrc) && ssrc != 0) { | |
| 175 return false; | |
| 176 } | |
| 177 if (mute) { | |
| 178 muted_streams_.insert(ssrc); | |
| 179 } else { | |
| 180 muted_streams_.erase(ssrc); | |
| 181 } | |
| 182 return true; | |
| 183 } | |
| 184 bool set_sending(bool send) { | |
| 185 sending_ = send; | |
| 186 return true; | |
| 187 } | |
| 188 void set_playout(bool playout) { playout_ = playout; } | |
| 189 bool SetRecvRtpHeaderExtensions( | |
| 190 const std::vector<RtpHeaderExtension>& extensions) { | |
| 191 recv_extensions_ = extensions; | |
| 192 return true; | |
| 193 } | |
| 194 bool SetSendRtpHeaderExtensions( | |
| 195 const std::vector<RtpHeaderExtension>& extensions) { | |
| 196 send_extensions_ = extensions; | |
| 197 return true; | |
| 198 } | |
| 199 virtual void OnPacketReceived(rtc::Buffer* packet, | |
| 200 const rtc::PacketTime& packet_time) { | |
| 201 rtp_packets_.push_back(std::string(packet->data<char>(), packet->size())); | |
| 202 } | |
| 203 virtual void OnRtcpReceived(rtc::Buffer* packet, | |
| 204 const rtc::PacketTime& packet_time) { | |
| 205 rtcp_packets_.push_back(std::string(packet->data<char>(), packet->size())); | |
| 206 } | |
| 207 virtual void OnReadyToSend(bool ready) { | |
| 208 ready_to_send_ = ready; | |
| 209 } | |
| 210 bool fail_set_send_codecs() const { return fail_set_send_codecs_; } | |
| 211 bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; } | |
| 212 | |
| 213 private: | |
| 214 bool sending_; | |
| 215 bool playout_; | |
| 216 std::vector<RtpHeaderExtension> recv_extensions_; | |
| 217 std::vector<RtpHeaderExtension> send_extensions_; | |
| 218 std::list<std::string> rtp_packets_; | |
| 219 std::list<std::string> rtcp_packets_; | |
| 220 std::vector<StreamParams> send_streams_; | |
| 221 std::vector<StreamParams> receive_streams_; | |
| 222 std::set<uint32_t> muted_streams_; | |
| 223 bool fail_set_send_codecs_; | |
| 224 bool fail_set_recv_codecs_; | |
| 225 uint32_t send_ssrc_; | |
| 226 std::string rtcp_cname_; | |
| 227 bool ready_to_send_; | |
| 228 }; | |
| 229 | |
| 230 class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> { | |
| 231 public: | |
| 232 struct DtmfInfo { | |
| 233 DtmfInfo(uint32_t ssrc, int event_code, int duration) | |
| 234 : ssrc(ssrc), | |
| 235 event_code(event_code), | |
| 236 duration(duration) {} | |
| 237 uint32_t ssrc; | |
| 238 int event_code; | |
| 239 int duration; | |
| 240 }; | |
| 241 explicit FakeVoiceMediaChannel(FakeVoiceEngine* engine, | |
| 242 const AudioOptions& options) | |
| 243 : engine_(engine), | |
| 244 time_since_last_typing_(-1) { | |
| 245 output_scalings_[0] = 1.0; // For default channel. | |
| 246 SetOptions(options); | |
| 247 } | |
| 248 ~FakeVoiceMediaChannel(); | |
| 249 const std::vector<AudioCodec>& recv_codecs() const { return recv_codecs_; } | |
| 250 const std::vector<AudioCodec>& send_codecs() const { return send_codecs_; } | |
| 251 const std::vector<AudioCodec>& codecs() const { return send_codecs(); } | |
| 252 const std::vector<DtmfInfo>& dtmf_info_queue() const { | |
| 253 return dtmf_info_queue_; | |
| 254 } | |
| 255 const AudioOptions& options() const { return options_; } | |
| 256 | |
| 257 virtual bool SetSendParameters(const AudioSendParameters& params) { | |
| 258 return (SetSendCodecs(params.codecs) && | |
| 259 SetSendRtpHeaderExtensions(params.extensions) && | |
| 260 SetMaxSendBandwidth(params.max_bandwidth_bps) && | |
| 261 SetOptions(params.options)); | |
| 262 } | |
| 263 | |
| 264 virtual bool SetRecvParameters(const AudioRecvParameters& params) { | |
| 265 return (SetRecvCodecs(params.codecs) && | |
| 266 SetRecvRtpHeaderExtensions(params.extensions)); | |
| 267 } | |
| 268 virtual bool SetPlayout(bool playout) { | |
| 269 set_playout(playout); | |
| 270 return true; | |
| 271 } | |
| 272 virtual bool SetSend(SendFlags flag) { | |
| 273 return set_sending(flag != SEND_NOTHING); | |
| 274 } | |
| 275 virtual bool SetAudioSend(uint32_t ssrc, | |
| 276 bool enable, | |
| 277 const AudioOptions* options, | |
| 278 AudioRenderer* renderer) { | |
| 279 if (!SetLocalRenderer(ssrc, renderer)) { | |
| 280 return false; | |
| 281 } | |
| 282 if (!RtpHelper<VoiceMediaChannel>::MuteStream(ssrc, !enable)) { | |
| 283 return false; | |
| 284 } | |
| 285 if (enable && options) { | |
| 286 return SetOptions(*options); | |
| 287 } | |
| 288 return true; | |
| 289 } | |
| 290 virtual bool AddRecvStream(const StreamParams& sp) { | |
| 291 if (!RtpHelper<VoiceMediaChannel>::AddRecvStream(sp)) | |
| 292 return false; | |
| 293 output_scalings_[sp.first_ssrc()] = 1.0; | |
| 294 return true; | |
| 295 } | |
| 296 virtual bool RemoveRecvStream(uint32_t ssrc) { | |
| 297 if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc)) | |
| 298 return false; | |
| 299 output_scalings_.erase(ssrc); | |
| 300 return true; | |
| 301 } | |
| 302 | |
| 303 virtual bool GetActiveStreams(AudioInfo::StreamList* streams) { return true; } | |
| 304 virtual int GetOutputLevel() { return 0; } | |
| 305 void set_time_since_last_typing(int ms) { time_since_last_typing_ = ms; } | |
| 306 virtual int GetTimeSinceLastTyping() { return time_since_last_typing_; } | |
| 307 virtual void SetTypingDetectionParameters( | |
| 308 int time_window, int cost_per_typing, int reporting_threshold, | |
| 309 int penalty_decay, int type_event_delay) {} | |
| 310 | |
| 311 virtual bool CanInsertDtmf() { | |
| 312 for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin(); | |
| 313 it != send_codecs_.end(); ++it) { | |
| 314 // Find the DTMF telephone event "codec". | |
| 315 if (_stricmp(it->name.c_str(), "telephone-event") == 0) { | |
| 316 return true; | |
| 317 } | |
| 318 } | |
| 319 return false; | |
| 320 } | |
| 321 virtual bool InsertDtmf(uint32_t ssrc, | |
| 322 int event_code, | |
| 323 int duration) { | |
| 324 dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration)); | |
| 325 return true; | |
| 326 } | |
| 327 | |
| 328 virtual bool SetOutputVolume(uint32_t ssrc, double volume) { | |
| 329 if (0 == ssrc) { | |
| 330 std::map<uint32_t, double>::iterator it; | |
| 331 for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) { | |
| 332 it->second = volume; | |
| 333 } | |
| 334 return true; | |
| 335 } else if (output_scalings_.find(ssrc) != output_scalings_.end()) { | |
| 336 output_scalings_[ssrc] = volume; | |
| 337 return true; | |
| 338 } | |
| 339 return false; | |
| 340 } | |
| 341 bool GetOutputVolume(uint32_t ssrc, double* volume) { | |
| 342 if (output_scalings_.find(ssrc) == output_scalings_.end()) | |
| 343 return false; | |
| 344 *volume = output_scalings_[ssrc]; | |
| 345 return true; | |
| 346 } | |
| 347 | |
| 348 virtual bool GetStats(VoiceMediaInfo* info) { return false; } | |
| 349 | |
| 350 virtual void SetRawAudioSink( | |
| 351 uint32_t ssrc, | |
| 352 rtc::scoped_ptr<webrtc::AudioSinkInterface> sink) { | |
| 353 sink_ = std::move(sink); | |
| 354 } | |
| 355 | |
| 356 private: | |
| 357 class VoiceChannelAudioSink : public AudioRenderer::Sink { | |
| 358 public: | |
| 359 explicit VoiceChannelAudioSink(AudioRenderer* renderer) | |
| 360 : renderer_(renderer) { | |
| 361 renderer_->SetSink(this); | |
| 362 } | |
| 363 virtual ~VoiceChannelAudioSink() { | |
| 364 if (renderer_) { | |
| 365 renderer_->SetSink(NULL); | |
| 366 } | |
| 367 } | |
| 368 void OnData(const void* audio_data, | |
| 369 int bits_per_sample, | |
| 370 int sample_rate, | |
| 371 size_t number_of_channels, | |
| 372 size_t number_of_frames) override {} | |
| 373 void OnClose() override { renderer_ = NULL; } | |
| 374 AudioRenderer* renderer() const { return renderer_; } | |
| 375 | |
| 376 private: | |
| 377 AudioRenderer* renderer_; | |
| 378 }; | |
| 379 | |
| 380 bool SetRecvCodecs(const std::vector<AudioCodec>& codecs) { | |
| 381 if (fail_set_recv_codecs()) { | |
| 382 // Fake the failure in SetRecvCodecs. | |
| 383 return false; | |
| 384 } | |
| 385 recv_codecs_ = codecs; | |
| 386 return true; | |
| 387 } | |
| 388 bool SetSendCodecs(const std::vector<AudioCodec>& codecs) { | |
| 389 if (fail_set_send_codecs()) { | |
| 390 // Fake the failure in SetSendCodecs. | |
| 391 return false; | |
| 392 } | |
| 393 send_codecs_ = codecs; | |
| 394 return true; | |
| 395 } | |
| 396 bool SetMaxSendBandwidth(int bps) { return true; } | |
| 397 bool SetOptions(const AudioOptions& options) { | |
| 398 // Does a "merge" of current options and set options. | |
| 399 options_.SetAll(options); | |
| 400 return true; | |
| 401 } | |
| 402 bool SetLocalRenderer(uint32_t ssrc, AudioRenderer* renderer) { | |
| 403 auto it = local_renderers_.find(ssrc); | |
| 404 if (renderer) { | |
| 405 if (it != local_renderers_.end()) { | |
| 406 ASSERT(it->second->renderer() == renderer); | |
| 407 } else { | |
| 408 local_renderers_.insert(std::make_pair( | |
| 409 ssrc, new VoiceChannelAudioSink(renderer))); | |
| 410 } | |
| 411 } else { | |
| 412 if (it != local_renderers_.end()) { | |
| 413 delete it->second; | |
| 414 local_renderers_.erase(it); | |
| 415 } | |
| 416 } | |
| 417 return true; | |
| 418 } | |
| 419 | |
| 420 FakeVoiceEngine* engine_; | |
| 421 std::vector<AudioCodec> recv_codecs_; | |
| 422 std::vector<AudioCodec> send_codecs_; | |
| 423 std::map<uint32_t, double> output_scalings_; | |
| 424 std::vector<DtmfInfo> dtmf_info_queue_; | |
| 425 int time_since_last_typing_; | |
| 426 AudioOptions options_; | |
| 427 std::map<uint32_t, VoiceChannelAudioSink*> local_renderers_; | |
| 428 rtc::scoped_ptr<webrtc::AudioSinkInterface> sink_; | |
| 429 }; | |
| 430 | |
| 431 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo. | |
| 432 inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info, | |
| 433 uint32_t ssrc, | |
| 434 int event_code, | |
| 435 int duration) { | |
| 436 return (info.duration == duration && info.event_code == event_code && | |
| 437 info.ssrc == ssrc); | |
| 438 } | |
| 439 | |
| 440 class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> { | |
| 441 public: | |
| 442 explicit FakeVideoMediaChannel(FakeVideoEngine* engine, | |
| 443 const VideoOptions& options) | |
| 444 : engine_(engine), max_bps_(-1) { | |
| 445 SetOptions(options); | |
| 446 } | |
| 447 | |
| 448 ~FakeVideoMediaChannel(); | |
| 449 | |
| 450 const std::vector<VideoCodec>& recv_codecs() const { return recv_codecs_; } | |
| 451 const std::vector<VideoCodec>& send_codecs() const { return send_codecs_; } | |
| 452 const std::vector<VideoCodec>& codecs() const { return send_codecs(); } | |
| 453 bool rendering() const { return playout(); } | |
| 454 const VideoOptions& options() const { return options_; } | |
| 455 const std::map<uint32_t, rtc::VideoSinkInterface<VideoFrame>*>& sinks() | |
| 456 const { | |
| 457 return sinks_; | |
| 458 } | |
| 459 int max_bps() const { return max_bps_; } | |
| 460 virtual bool SetSendParameters(const VideoSendParameters& params) { | |
| 461 return (SetSendCodecs(params.codecs) && | |
| 462 SetSendRtpHeaderExtensions(params.extensions) && | |
| 463 SetMaxSendBandwidth(params.max_bandwidth_bps) && | |
| 464 SetOptions(params.options)); | |
| 465 } | |
| 466 | |
| 467 virtual bool SetRecvParameters(const VideoRecvParameters& params) { | |
| 468 return (SetRecvCodecs(params.codecs) && | |
| 469 SetRecvRtpHeaderExtensions(params.extensions)); | |
| 470 } | |
| 471 virtual bool AddSendStream(const StreamParams& sp) { | |
| 472 return RtpHelper<VideoMediaChannel>::AddSendStream(sp); | |
| 473 } | |
| 474 virtual bool RemoveSendStream(uint32_t ssrc) { | |
| 475 return RtpHelper<VideoMediaChannel>::RemoveSendStream(ssrc); | |
| 476 } | |
| 477 | |
| 478 virtual bool GetSendCodec(VideoCodec* send_codec) { | |
| 479 if (send_codecs_.empty()) { | |
| 480 return false; | |
| 481 } | |
| 482 *send_codec = send_codecs_[0]; | |
| 483 return true; | |
| 484 } | |
| 485 bool SetSink(uint32_t ssrc, | |
| 486 rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override { | |
| 487 if (ssrc != 0 && sinks_.find(ssrc) == sinks_.end()) { | |
| 488 return false; | |
| 489 } | |
| 490 if (ssrc != 0) { | |
| 491 sinks_[ssrc] = sink; | |
| 492 } | |
| 493 return true; | |
| 494 } | |
| 495 | |
| 496 virtual bool SetSend(bool send) { return set_sending(send); } | |
| 497 virtual bool SetVideoSend(uint32_t ssrc, bool enable, | |
| 498 const VideoOptions* options) { | |
| 499 if (!RtpHelper<VideoMediaChannel>::MuteStream(ssrc, !enable)) { | |
| 500 return false; | |
| 501 } | |
| 502 if (enable && options) { | |
| 503 return SetOptions(*options); | |
| 504 } | |
| 505 return true; | |
| 506 } | |
| 507 virtual bool SetCapturer(uint32_t ssrc, VideoCapturer* capturer) { | |
| 508 capturers_[ssrc] = capturer; | |
| 509 return true; | |
| 510 } | |
| 511 bool HasCapturer(uint32_t ssrc) const { | |
| 512 return capturers_.find(ssrc) != capturers_.end(); | |
| 513 } | |
| 514 virtual bool AddRecvStream(const StreamParams& sp) { | |
| 515 if (!RtpHelper<VideoMediaChannel>::AddRecvStream(sp)) | |
| 516 return false; | |
| 517 sinks_[sp.first_ssrc()] = NULL; | |
| 518 return true; | |
| 519 } | |
| 520 virtual bool RemoveRecvStream(uint32_t ssrc) { | |
| 521 if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc)) | |
| 522 return false; | |
| 523 sinks_.erase(ssrc); | |
| 524 return true; | |
| 525 } | |
| 526 | |
| 527 virtual bool GetStats(VideoMediaInfo* info) { return false; } | |
| 528 | |
| 529 private: | |
| 530 bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) { | |
| 531 if (fail_set_recv_codecs()) { | |
| 532 // Fake the failure in SetRecvCodecs. | |
| 533 return false; | |
| 534 } | |
| 535 recv_codecs_ = codecs; | |
| 536 return true; | |
| 537 } | |
| 538 bool SetSendCodecs(const std::vector<VideoCodec>& codecs) { | |
| 539 if (fail_set_send_codecs()) { | |
| 540 // Fake the failure in SetSendCodecs. | |
| 541 return false; | |
| 542 } | |
| 543 send_codecs_ = codecs; | |
| 544 | |
| 545 return true; | |
| 546 } | |
| 547 bool SetOptions(const VideoOptions& options) { | |
| 548 options_ = options; | |
| 549 return true; | |
| 550 } | |
| 551 bool SetMaxSendBandwidth(int bps) { | |
| 552 max_bps_ = bps; | |
| 553 return true; | |
| 554 } | |
| 555 | |
| 556 FakeVideoEngine* engine_; | |
| 557 std::vector<VideoCodec> recv_codecs_; | |
| 558 std::vector<VideoCodec> send_codecs_; | |
| 559 std::map<uint32_t, rtc::VideoSinkInterface<VideoFrame>*> sinks_; | |
| 560 std::map<uint32_t, VideoCapturer*> capturers_; | |
| 561 VideoOptions options_; | |
| 562 int max_bps_; | |
| 563 }; | |
| 564 | |
| 565 class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> { | |
| 566 public: | |
| 567 explicit FakeDataMediaChannel(void* unused, const DataOptions& options) | |
| 568 : send_blocked_(false), max_bps_(-1) {} | |
| 569 ~FakeDataMediaChannel() {} | |
| 570 const std::vector<DataCodec>& recv_codecs() const { return recv_codecs_; } | |
| 571 const std::vector<DataCodec>& send_codecs() const { return send_codecs_; } | |
| 572 const std::vector<DataCodec>& codecs() const { return send_codecs(); } | |
| 573 int max_bps() const { return max_bps_; } | |
| 574 | |
| 575 virtual bool SetSendParameters(const DataSendParameters& params) { | |
| 576 return (SetSendCodecs(params.codecs) && | |
| 577 SetMaxSendBandwidth(params.max_bandwidth_bps)); | |
| 578 } | |
| 579 virtual bool SetRecvParameters(const DataRecvParameters& params) { | |
| 580 return SetRecvCodecs(params.codecs); | |
| 581 } | |
| 582 virtual bool SetSend(bool send) { return set_sending(send); } | |
| 583 virtual bool SetReceive(bool receive) { | |
| 584 set_playout(receive); | |
| 585 return true; | |
| 586 } | |
| 587 virtual bool AddRecvStream(const StreamParams& sp) { | |
| 588 if (!RtpHelper<DataMediaChannel>::AddRecvStream(sp)) | |
| 589 return false; | |
| 590 return true; | |
| 591 } | |
| 592 virtual bool RemoveRecvStream(uint32_t ssrc) { | |
| 593 if (!RtpHelper<DataMediaChannel>::RemoveRecvStream(ssrc)) | |
| 594 return false; | |
| 595 return true; | |
| 596 } | |
| 597 | |
| 598 virtual bool SendData(const SendDataParams& params, | |
| 599 const rtc::Buffer& payload, | |
| 600 SendDataResult* result) { | |
| 601 if (send_blocked_) { | |
| 602 *result = SDR_BLOCK; | |
| 603 return false; | |
| 604 } else { | |
| 605 last_sent_data_params_ = params; | |
| 606 last_sent_data_ = std::string(payload.data<char>(), payload.size()); | |
| 607 return true; | |
| 608 } | |
| 609 } | |
| 610 | |
| 611 SendDataParams last_sent_data_params() { return last_sent_data_params_; } | |
| 612 std::string last_sent_data() { return last_sent_data_; } | |
| 613 bool is_send_blocked() { return send_blocked_; } | |
| 614 void set_send_blocked(bool blocked) { send_blocked_ = blocked; } | |
| 615 | |
| 616 private: | |
| 617 bool SetRecvCodecs(const std::vector<DataCodec>& codecs) { | |
| 618 if (fail_set_recv_codecs()) { | |
| 619 // Fake the failure in SetRecvCodecs. | |
| 620 return false; | |
| 621 } | |
| 622 recv_codecs_ = codecs; | |
| 623 return true; | |
| 624 } | |
| 625 bool SetSendCodecs(const std::vector<DataCodec>& codecs) { | |
| 626 if (fail_set_send_codecs()) { | |
| 627 // Fake the failure in SetSendCodecs. | |
| 628 return false; | |
| 629 } | |
| 630 send_codecs_ = codecs; | |
| 631 return true; | |
| 632 } | |
| 633 bool SetMaxSendBandwidth(int bps) { | |
| 634 max_bps_ = bps; | |
| 635 return true; | |
| 636 } | |
| 637 | |
| 638 std::vector<DataCodec> recv_codecs_; | |
| 639 std::vector<DataCodec> send_codecs_; | |
| 640 SendDataParams last_sent_data_params_; | |
| 641 std::string last_sent_data_; | |
| 642 bool send_blocked_; | |
| 643 int max_bps_; | |
| 644 }; | |
| 645 | |
| 646 // A base class for all of the shared parts between FakeVoiceEngine | |
| 647 // and FakeVideoEngine. | |
| 648 class FakeBaseEngine { | |
| 649 public: | |
| 650 FakeBaseEngine() | |
| 651 : options_changed_(false), | |
| 652 fail_create_channel_(false) {} | |
| 653 void set_fail_create_channel(bool fail) { fail_create_channel_ = fail; } | |
| 654 | |
| 655 RtpCapabilities GetCapabilities() const { return capabilities_; } | |
| 656 void set_rtp_header_extensions( | |
| 657 const std::vector<RtpHeaderExtension>& extensions) { | |
| 658 capabilities_.header_extensions = extensions; | |
| 659 } | |
| 660 | |
| 661 protected: | |
| 662 // Flag used by optionsmessagehandler_unittest for checking whether any | |
| 663 // relevant setting has been updated. | |
| 664 // TODO(thaloun): Replace with explicit checks of before & after values. | |
| 665 bool options_changed_; | |
| 666 bool fail_create_channel_; | |
| 667 RtpCapabilities capabilities_; | |
| 668 }; | |
| 669 | |
| 670 class FakeVoiceEngine : public FakeBaseEngine { | |
| 671 public: | |
| 672 FakeVoiceEngine() | |
| 673 : output_volume_(-1) { | |
| 674 // Add a fake audio codec. Note that the name must not be "" as there are | |
| 675 // sanity checks against that. | |
| 676 codecs_.push_back(AudioCodec(101, "fake_audio_codec", 0, 0, 1, 0)); | |
| 677 } | |
| 678 bool Init(rtc::Thread* worker_thread) { return true; } | |
| 679 void Terminate() {} | |
| 680 rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const { | |
| 681 return rtc::scoped_refptr<webrtc::AudioState>(); | |
| 682 } | |
| 683 | |
| 684 VoiceMediaChannel* CreateChannel(webrtc::Call* call, | |
| 685 const AudioOptions& options) { | |
| 686 if (fail_create_channel_) { | |
| 687 return nullptr; | |
| 688 } | |
| 689 | |
| 690 FakeVoiceMediaChannel* ch = new FakeVoiceMediaChannel(this, options); | |
| 691 channels_.push_back(ch); | |
| 692 return ch; | |
| 693 } | |
| 694 FakeVoiceMediaChannel* GetChannel(size_t index) { | |
| 695 return (channels_.size() > index) ? channels_[index] : NULL; | |
| 696 } | |
| 697 void UnregisterChannel(VoiceMediaChannel* channel) { | |
| 698 channels_.erase(std::find(channels_.begin(), channels_.end(), channel)); | |
| 699 } | |
| 700 | |
| 701 const std::vector<AudioCodec>& codecs() { return codecs_; } | |
| 702 void SetCodecs(const std::vector<AudioCodec> codecs) { codecs_ = codecs; } | |
| 703 | |
| 704 bool GetOutputVolume(int* level) { | |
| 705 *level = output_volume_; | |
| 706 return true; | |
| 707 } | |
| 708 bool SetOutputVolume(int level) { | |
| 709 output_volume_ = level; | |
| 710 return true; | |
| 711 } | |
| 712 | |
| 713 int GetInputLevel() { return 0; } | |
| 714 | |
| 715 bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) { | |
| 716 return false; | |
| 717 } | |
| 718 | |
| 719 void StopAecDump() {} | |
| 720 | |
| 721 bool StartRtcEventLog(rtc::PlatformFile file) { return false; } | |
| 722 | |
| 723 void StopRtcEventLog() {} | |
| 724 | |
| 725 private: | |
| 726 std::vector<FakeVoiceMediaChannel*> channels_; | |
| 727 std::vector<AudioCodec> codecs_; | |
| 728 int output_volume_; | |
| 729 | |
| 730 friend class FakeMediaEngine; | |
| 731 }; | |
| 732 | |
| 733 class FakeVideoEngine : public FakeBaseEngine { | |
| 734 public: | |
| 735 FakeVideoEngine() : capture_(false) { | |
| 736 // Add a fake video codec. Note that the name must not be "" as there are | |
| 737 // sanity checks against that. | |
| 738 codecs_.push_back(VideoCodec(0, "fake_video_codec", 0, 0, 0, 0)); | |
| 739 } | |
| 740 void Init() {} | |
| 741 bool SetOptions(const VideoOptions& options) { | |
| 742 options_ = options; | |
| 743 options_changed_ = true; | |
| 744 return true; | |
| 745 } | |
| 746 | |
| 747 VideoMediaChannel* CreateChannel(webrtc::Call* call, | |
| 748 const VideoOptions& options) { | |
| 749 if (fail_create_channel_) { | |
| 750 return NULL; | |
| 751 } | |
| 752 | |
| 753 FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this, options); | |
| 754 channels_.push_back(ch); | |
| 755 return ch; | |
| 756 } | |
| 757 FakeVideoMediaChannel* GetChannel(size_t index) { | |
| 758 return (channels_.size() > index) ? channels_[index] : NULL; | |
| 759 } | |
| 760 void UnregisterChannel(VideoMediaChannel* channel) { | |
| 761 channels_.erase(std::find(channels_.begin(), channels_.end(), channel)); | |
| 762 } | |
| 763 | |
| 764 const std::vector<VideoCodec>& codecs() const { return codecs_; } | |
| 765 void SetCodecs(const std::vector<VideoCodec> codecs) { codecs_ = codecs; } | |
| 766 | |
| 767 bool SetCaptureDevice(const Device* device) { | |
| 768 in_device_ = (device) ? device->name : ""; | |
| 769 options_changed_ = true; | |
| 770 return true; | |
| 771 } | |
| 772 bool SetCapture(bool capture) { | |
| 773 capture_ = capture; | |
| 774 return true; | |
| 775 } | |
| 776 | |
| 777 private: | |
| 778 std::vector<FakeVideoMediaChannel*> channels_; | |
| 779 std::vector<VideoCodec> codecs_; | |
| 780 std::string in_device_; | |
| 781 bool capture_; | |
| 782 VideoOptions options_; | |
| 783 | |
| 784 friend class FakeMediaEngine; | |
| 785 }; | |
| 786 | |
| 787 class FakeMediaEngine : | |
| 788 public CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine> { | |
| 789 public: | |
| 790 FakeMediaEngine() {} | |
| 791 virtual ~FakeMediaEngine() {} | |
| 792 | |
| 793 void SetAudioCodecs(const std::vector<AudioCodec>& codecs) { | |
| 794 voice_.SetCodecs(codecs); | |
| 795 } | |
| 796 void SetVideoCodecs(const std::vector<VideoCodec>& codecs) { | |
| 797 video_.SetCodecs(codecs); | |
| 798 } | |
| 799 | |
| 800 void SetAudioRtpHeaderExtensions( | |
| 801 const std::vector<RtpHeaderExtension>& extensions) { | |
| 802 voice_.set_rtp_header_extensions(extensions); | |
| 803 } | |
| 804 void SetVideoRtpHeaderExtensions( | |
| 805 const std::vector<RtpHeaderExtension>& extensions) { | |
| 806 video_.set_rtp_header_extensions(extensions); | |
| 807 } | |
| 808 | |
| 809 FakeVoiceMediaChannel* GetVoiceChannel(size_t index) { | |
| 810 return voice_.GetChannel(index); | |
| 811 } | |
| 812 FakeVideoMediaChannel* GetVideoChannel(size_t index) { | |
| 813 return video_.GetChannel(index); | |
| 814 } | |
| 815 | |
| 816 int output_volume() const { return voice_.output_volume_; } | |
| 817 bool capture() const { return video_.capture_; } | |
| 818 bool options_changed() const { | |
| 819 return video_.options_changed_; | |
| 820 } | |
| 821 void clear_options_changed() { | |
| 822 video_.options_changed_ = false; | |
| 823 } | |
| 824 void set_fail_create_channel(bool fail) { | |
| 825 voice_.set_fail_create_channel(fail); | |
| 826 video_.set_fail_create_channel(fail); | |
| 827 } | |
| 828 }; | |
| 829 | |
| 830 // CompositeMediaEngine with FakeVoiceEngine to expose SetAudioCodecs to | |
| 831 // establish a media connectionwith minimum set of audio codes required | |
| 832 template <class VIDEO> | |
| 833 class CompositeMediaEngineWithFakeVoiceEngine : | |
| 834 public CompositeMediaEngine<FakeVoiceEngine, VIDEO> { | |
| 835 public: | |
| 836 CompositeMediaEngineWithFakeVoiceEngine() {} | |
| 837 virtual ~CompositeMediaEngineWithFakeVoiceEngine() {} | |
| 838 | |
| 839 virtual void SetAudioCodecs(const std::vector<AudioCodec>& codecs) { | |
| 840 CompositeMediaEngine<FakeVoiceEngine, VIDEO>::voice_.SetCodecs(codecs); | |
| 841 } | |
| 842 }; | |
| 843 | |
| 844 // Have to come afterwards due to declaration order | |
| 845 inline FakeVoiceMediaChannel::~FakeVoiceMediaChannel() { | |
| 846 if (engine_) { | |
| 847 engine_->UnregisterChannel(this); | |
| 848 } | |
| 849 } | |
| 850 | |
| 851 inline FakeVideoMediaChannel::~FakeVideoMediaChannel() { | |
| 852 if (engine_) { | |
| 853 engine_->UnregisterChannel(this); | |
| 854 } | |
| 855 } | |
| 856 | |
| 857 class FakeDataEngine : public DataEngineInterface { | |
| 858 public: | |
| 859 FakeDataEngine() : last_channel_type_(DCT_NONE) {} | |
| 860 | |
| 861 virtual DataMediaChannel* CreateChannel(DataChannelType data_channel_type) { | |
| 862 last_channel_type_ = data_channel_type; | |
| 863 FakeDataMediaChannel* ch = new FakeDataMediaChannel(this, DataOptions()); | |
| 864 channels_.push_back(ch); | |
| 865 return ch; | |
| 866 } | |
| 867 | |
| 868 FakeDataMediaChannel* GetChannel(size_t index) { | |
| 869 return (channels_.size() > index) ? channels_[index] : NULL; | |
| 870 } | |
| 871 | |
| 872 void UnregisterChannel(DataMediaChannel* channel) { | |
| 873 channels_.erase(std::find(channels_.begin(), channels_.end(), channel)); | |
| 874 } | |
| 875 | |
| 876 virtual void SetDataCodecs(const std::vector<DataCodec>& data_codecs) { | |
| 877 data_codecs_ = data_codecs; | |
| 878 } | |
| 879 | |
| 880 virtual const std::vector<DataCodec>& data_codecs() { return data_codecs_; } | |
| 881 | |
| 882 DataChannelType last_channel_type() const { return last_channel_type_; } | |
| 883 | |
| 884 private: | |
| 885 std::vector<FakeDataMediaChannel*> channels_; | |
| 886 std::vector<DataCodec> data_codecs_; | |
| 887 DataChannelType last_channel_type_; | |
| 888 }; | |
| 889 | |
| 890 } // namespace cricket | |
| 891 | |
| 892 #endif // TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1587193006:
Move talk/media to webrtc/media (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master