src/third_party/libjingle/source/talk/media/base/fakemediaengine.h

   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/base/buffer.h"
  38 #include "talk/base/stringutils.h"
  39 #include "talk/media/base/audiorenderer.h"
  40 #include "talk/media/base/mediaengine.h"
  41 #include "talk/media/base/rtputils.h"
  42 #include "talk/media/base/streamparams.h"
  43 #include "talk/p2p/base/sessiondescription.h"
  44
  45 namespace cricket {
  46
  47 class FakeMediaEngine;
  48 class FakeVideoEngine;
  49 class FakeVoiceEngine;
  50
  51 // A common helper class that handles sending and receiving RTP/RTCP packets.
  52 template <class Base> class RtpHelper : public Base {
  53  public:
  54   RtpHelper()
  55       : sending_(false),
  56         playout_(false),
  57         fail_set_send_codecs_(false),
  58         fail_set_recv_codecs_(false),
  59         send_ssrc_(0),
  60         ready_to_send_(false) {}
  61   const std::vector<RtpHeaderExtension>& recv_extensions() {
  62     return recv_extensions_;
  63   }
  64   const std::vector<RtpHeaderExtension>& send_extensions() {
  65     return send_extensions_;
  66   }
  67   bool sending() const { return sending_; }
  68   bool playout() const { return playout_; }
  69   const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
  70   const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
  71
  72   bool SendRtp(const void* data, int len) {
  73     if (!sending_) {
  74       return false;
  75     }
  76     talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
  77     return Base::SendPacket(&packet);
  78   }
  79   bool SendRtcp(const void* data, int len) {
  80     talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
  81     return Base::SendRtcp(&packet);
  82   }
  83
  84   bool CheckRtp(const void* data, int len) {
  85     bool success = !rtp_packets_.empty();
  86     if (success) {
  87       std::string packet = rtp_packets_.front();
  88       rtp_packets_.pop_front();
  89       success = (packet == std::string(static_cast<const char*>(data), len));
  90     }
  91     return success;
  92   }
  93   bool CheckRtcp(const void* data, int len) {
  94     bool success = !rtcp_packets_.empty();
  95     if (success) {
  96       std::string packet = rtcp_packets_.front();
  97       rtcp_packets_.pop_front();
  98       success = (packet == std::string(static_cast<const char*>(data), len));
  99     }
 100     return success;
 101   }
 102   bool CheckNoRtp() { return rtp_packets_.empty(); }
 103   bool CheckNoRtcp() { return rtcp_packets_.empty(); }
 104   virtual bool SetRecvRtpHeaderExtensions(
 105       const std::vector<RtpHeaderExtension>& extensions) {
 106     recv_extensions_ = extensions;
 107     return true;
 108   }
 109   virtual bool SetSendRtpHeaderExtensions(
 110       const std::vector<RtpHeaderExtension>& extensions) {
 111     send_extensions_ = extensions;
 112     return true;
 113   }
 114   void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; }
 115   void set_fail_set_recv_codecs(bool fail) { fail_set_recv_codecs_ = fail; }
 116   virtual bool AddSendStream(const StreamParams& sp) {
 117     if (std::find(send_streams_.begin(), send_streams_.end(), sp) !=
 118         send_streams_.end()) {
 119       return false;
 120     }
 121     send_streams_.push_back(sp);
 122     return true;
 123   }
 124   virtual bool RemoveSendStream(uint32 ssrc) {
 125     return RemoveStreamBySsrc(&send_streams_, ssrc);
 126   }
 127   virtual bool AddRecvStream(const StreamParams& sp) {
 128     if (std::find(receive_streams_.begin(), receive_streams_.end(), sp) !=
 129         receive_streams_.end()) {
 130       return false;
 131     }
 132     receive_streams_.push_back(sp);
 133     return true;
 134   }
 135   virtual bool RemoveRecvStream(uint32 ssrc) {
 136     return RemoveStreamBySsrc(&receive_streams_, ssrc);
 137   }
 138   virtual bool MuteStream(uint32 ssrc, bool on) {
 139     if (!HasSendStream(ssrc) && ssrc != 0)
 140       return false;
 141     if (on)
 142       muted_streams_.insert(ssrc);
 143     else
 144       muted_streams_.erase(ssrc);
 145     return true;
 146   }
 147   bool IsStreamMuted(uint32 ssrc) const {
 148     bool ret = muted_streams_.find(ssrc) != muted_streams_.end();
 149     // If |ssrc = 0| check if the first send stream is muted.
 150     if (!ret && ssrc == 0 && !send_streams_.empty()) {
 151       return muted_streams_.find(send_streams_[0].first_ssrc()) !=
 152              muted_streams_.end();
 153     }
 154     return ret;
 155   }
 156   const std::vector<StreamParams>& send_streams() const {
 157     return send_streams_;
 158   }
 159   const std::vector<StreamParams>& recv_streams() const {
 160     return receive_streams_;
 161   }
 162   bool HasRecvStream(uint32 ssrc) const {
 163     return GetStreamBySsrc(receive_streams_, ssrc, NULL);
 164   }
 165   bool HasSendStream(uint32 ssrc) const {
 166     return GetStreamBySsrc(send_streams_, ssrc, NULL);
 167   }
 168   // TODO(perkj): This is to support legacy unit test that only check one
 169   // sending stream.
 170   const uint32 send_ssrc() {
 171     if (send_streams_.empty())
 172       return 0;
 173     return send_streams_[0].first_ssrc();
 174   }
 175
 176   // TODO(perkj): This is to support legacy unit test that only check one
 177   // sending stream.
 178   const std::string rtcp_cname() {
 179     if (send_streams_.empty())
 180       return "";
 181     return send_streams_[0].cname;
 182   }
 183
 184   bool ready_to_send() const {
 185     return ready_to_send_;
 186   }
 187
 188  protected:
 189   bool set_sending(bool send) {
 190     sending_ = send;
 191     return true;
 192   }
 193   void set_playout(bool playout) { playout_ = playout; }
 194   virtual void OnPacketReceived(talk_base::Buffer* packet,
 195                                 const talk_base::PacketTime& packet_time) {
 196     rtp_packets_.push_back(std::string(packet->data(), packet->length()));
 197   }
 198   virtual void OnRtcpReceived(talk_base::Buffer* packet,
 199                               const talk_base::PacketTime& packet_time) {
 200     rtcp_packets_.push_back(std::string(packet->data(), packet->length()));
 201   }
 202   virtual void OnReadyToSend(bool ready) {
 203     ready_to_send_ = ready;
 204   }
 205   bool fail_set_send_codecs() const { return fail_set_send_codecs_; }
 206   bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; }
 207
 208  private:
 209   bool sending_;
 210   bool playout_;
 211   std::vector<RtpHeaderExtension> recv_extensions_;
 212   std::vector<RtpHeaderExtension> send_extensions_;
 213   std::list<std::string> rtp_packets_;
 214   std::list<std::string> rtcp_packets_;
 215   std::vector<StreamParams> send_streams_;
 216   std::vector<StreamParams> receive_streams_;
 217   std::set<uint32> muted_streams_;
 218   bool fail_set_send_codecs_;
 219   bool fail_set_recv_codecs_;
 220   uint32 send_ssrc_;
 221   std::string rtcp_cname_;
 222   bool ready_to_send_;
 223 };
 224
 225 class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
 226  public:
 227   struct DtmfInfo {
 228     DtmfInfo(uint32 ssrc, int event_code, int duration, int flags)
 229         : ssrc(ssrc), event_code(event_code), duration(duration), flags(flags) {
 230     }
 231     uint32 ssrc;
 232     int event_code;
 233     int duration;
 234     int flags;
 235   };
 236   explicit FakeVoiceMediaChannel(FakeVoiceEngine* engine)
 237       : engine_(engine),
 238         fail_set_send_(false),
 239         ringback_tone_ssrc_(0),
 240         ringback_tone_play_(false),
 241         ringback_tone_loop_(false),
 242         time_since_last_typing_(-1) {
 243     output_scalings_[0] = OutputScaling();  // For default channel.
 244   }
 245   ~FakeVoiceMediaChannel();
 246   const std::vector<AudioCodec>& recv_codecs() const { return recv_codecs_; }
 247   const std::vector<AudioCodec>& send_codecs() const { return send_codecs_; }
 248   const std::vector<AudioCodec>& codecs() const { return send_codecs(); }
 249   const std::vector<DtmfInfo>& dtmf_info_queue() const {
 250     return dtmf_info_queue_;
 251   }
 252   const AudioOptions& options() const { return options_; }
 253
 254   uint32 ringback_tone_ssrc() const { return ringback_tone_ssrc_; }
 255   bool ringback_tone_play() const { return ringback_tone_play_; }
 256   bool ringback_tone_loop() const { return ringback_tone_loop_; }
 257
 258   virtual bool SetRecvCodecs(const std::vector<AudioCodec>& codecs) {
 259     if (fail_set_recv_codecs()) {
 260       // Fake the failure in SetRecvCodecs.
 261       return false;
 262     }
 263     recv_codecs_ = codecs;
 264     return true;
 265   }
 266   virtual bool SetSendCodecs(const std::vector<AudioCodec>& codecs) {
 267     if (fail_set_send_codecs()) {
 268       // Fake the failure in SetSendCodecs.
 269       return false;
 270     }
 271     send_codecs_ = codecs;
 272     return true;
 273   }
 274   virtual bool SetPlayout(bool playout) {
 275     set_playout(playout);
 276     return true;
 277   }
 278   virtual bool SetSend(SendFlags flag) {
 279     if (fail_set_send_) {
 280       return false;
 281     }
 282     return set_sending(flag != SEND_NOTHING);
 283   }
 284   virtual bool SetStartSendBandwidth(int bps) { return true; }
 285   virtual bool SetMaxSendBandwidth(int bps) { return true; }
 286   virtual bool AddRecvStream(const StreamParams& sp) {
 287     if (!RtpHelper<VoiceMediaChannel>::AddRecvStream(sp))
 288       return false;
 289     output_scalings_[sp.first_ssrc()] = OutputScaling();
 290     return true;
 291   }
 292   virtual bool RemoveRecvStream(uint32 ssrc) {
 293     if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
 294       return false;
 295     output_scalings_.erase(ssrc);
 296     return true;
 297   }
 298   virtual bool SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer) {
 299     std::map<uint32, AudioRenderer*>::iterator it =
 300         remote_renderers_.find(ssrc);
 301     if (renderer) {
 302       if (it != remote_renderers_.end()) {
 303         ASSERT(it->second == renderer);
 304       } else {
 305         remote_renderers_.insert(std::make_pair(ssrc, renderer));
 306         renderer->AddChannel(0);
 307       }
 308     } else {
 309       if (it != remote_renderers_.end()) {
 310         it->second->RemoveChannel(0);
 311         remote_renderers_.erase(it);
 312       } else {
 313         return false;
 314       }
 315     }
 316     return true;
 317   }
 318   virtual bool SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer) {
 319     std::map<uint32, AudioRenderer*>::iterator it = local_renderers_.find(ssrc);
 320     if (renderer) {
 321       if (it != local_renderers_.end()) {
 322         ASSERT(it->second == renderer);
 323       } else {
 324         local_renderers_.insert(std::make_pair(ssrc, renderer));
 325         renderer->AddChannel(0);
 326       }
 327     } else {
 328       if (it != local_renderers_.end()) {
 329         it->second->RemoveChannel(0);
 330         local_renderers_.erase(it);
 331       } else {
 332         return false;
 333       }
 334     }
 335     return true;
 336   }
 337
 338   virtual bool GetActiveStreams(AudioInfo::StreamList* streams) { return true; }
 339   virtual int GetOutputLevel() { return 0; }
 340   void set_time_since_last_typing(int ms) { time_since_last_typing_ = ms; }
 341   virtual int GetTimeSinceLastTyping() { return time_since_last_typing_; }
 342   virtual void SetTypingDetectionParameters(
 343       int time_window, int cost_per_typing, int reporting_threshold,
 344       int penalty_decay, int type_event_delay) {}
 345
 346   virtual bool SetRingbackTone(const char* buf, int len) { return true; }
 347   virtual bool PlayRingbackTone(uint32 ssrc, bool play, bool loop) {
 348     ringback_tone_ssrc_ = ssrc;
 349     ringback_tone_play_ = play;
 350     ringback_tone_loop_ = loop;
 351     return true;
 352   }
 353
 354   virtual bool CanInsertDtmf() {
 355     for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin();
 356          it != send_codecs_.end(); ++it) {
 357       // Find the DTMF telephone event "codec".
 358       if (_stricmp(it->name.c_str(), "telephone-event") == 0) {
 359         return true;
 360       }
 361     }
 362     return false;
 363   }
 364   virtual bool InsertDtmf(uint32 ssrc, int event_code, int duration,
 365                           int flags) {
 366     dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration, flags));
 367     return true;
 368   }
 369
 370   virtual bool SetOutputScaling(uint32 ssrc, double left, double right) {
 371     if (0 == ssrc) {
 372       std::map<uint32, OutputScaling>::iterator it;
 373       for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) {
 374         it->second.left = left;
 375         it->second.right = right;
 376       }
 377       return true;
 378     } else if (output_scalings_.find(ssrc) != output_scalings_.end()) {
 379       output_scalings_[ssrc].left = left;
 380       output_scalings_[ssrc].right = right;
 381       return true;
 382     }
 383     return false;
 384   }
 385   virtual bool GetOutputScaling(uint32 ssrc, double* left, double* right) {
 386     if (output_scalings_.find(ssrc) == output_scalings_.end())
 387       return false;
 388     *left = output_scalings_[ssrc].left;
 389     *right = output_scalings_[ssrc].right;
 390     return true;
 391   }
 392
 393   virtual bool GetStats(VoiceMediaInfo* info) { return false; }
 394   virtual void GetLastMediaError(uint32* ssrc,
 395                                  VoiceMediaChannel::Error* error) {
 396     *ssrc = 0;
 397     *error = fail_set_send_ ? VoiceMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED
 398                             : VoiceMediaChannel::ERROR_NONE;
 399   }
 400
 401   void set_fail_set_send(bool fail) { fail_set_send_ = fail; }
 402   void TriggerError(uint32 ssrc, VoiceMediaChannel::Error error) {
 403     VoiceMediaChannel::SignalMediaError(ssrc, error);
 404   }
 405
 406   virtual bool SetOptions(const AudioOptions& options) {
 407     // Does a "merge" of current options and set options.
 408     options_.SetAll(options);
 409     return true;
 410   }
 411   virtual bool GetOptions(AudioOptions* options) const {
 412     *options = options_;
 413     return true;
 414   }
 415
 416  private:
 417   struct OutputScaling {
 418     OutputScaling() : left(1.0), right(1.0) {}
 419     double left, right;
 420   };
 421
 422   FakeVoiceEngine* engine_;
 423   std::vector<AudioCodec> recv_codecs_;
 424   std::vector<AudioCodec> send_codecs_;
 425   std::map<uint32, OutputScaling> output_scalings_;
 426   std::vector<DtmfInfo> dtmf_info_queue_;
 427   bool fail_set_send_;
 428   uint32 ringback_tone_ssrc_;
 429   bool ringback_tone_play_;
 430   bool ringback_tone_loop_;
 431   int time_since_last_typing_;
 432   AudioOptions options_;
 433   std::map<uint32, AudioRenderer*> local_renderers_;
 434   std::map<uint32, AudioRenderer*> remote_renderers_;
 435 };
 436
 437 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo.
 438 inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
 439                             uint32 ssrc, int event_code, int duration,
 440                             int flags) {
 441   return (info.duration == duration && info.event_code == event_code &&
 442           info.flags == flags && info.ssrc == ssrc);
 443 }
 444
 445 class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
 446  public:
 447   explicit FakeVideoMediaChannel(FakeVideoEngine* engine)
 448       : engine_(engine),
 449         sent_intra_frame_(false),
 450         requested_intra_frame_(false),
 451         start_bps_(-1),
 452         max_bps_(-1) {}
 453   ~FakeVideoMediaChannel();
 454
 455   const std::vector<VideoCodec>& recv_codecs() const { return recv_codecs_; }
 456   const std::vector<VideoCodec>& send_codecs() const { return send_codecs_; }
 457   const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
 458   bool rendering() const { return playout(); }
 459   const VideoOptions& options() const { return options_; }
 460   const std::map<uint32, VideoRenderer*>& renderers() const {
 461     return renderers_;
 462   }
 463   int start_bps() const { return start_bps_; }
 464   int max_bps() const { return max_bps_; }
 465   bool GetSendStreamFormat(uint32 ssrc, VideoFormat* format) {
 466     if (send_formats_.find(ssrc) == send_formats_.end()) {
 467       return false;
 468     }
 469     *format = send_formats_[ssrc];
 470     return true;
 471   }
 472   virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) {
 473     if (send_formats_.find(ssrc) == send_formats_.end()) {
 474       return false;
 475     }
 476     send_formats_[ssrc] = format;
 477     return true;
 478   }
 479
 480   virtual bool AddSendStream(const StreamParams& sp) {
 481     if (!RtpHelper<VideoMediaChannel>::AddSendStream(sp)) {
 482       return false;
 483     }
 484     SetSendStreamDefaultFormat(sp.first_ssrc());
 485     return true;
 486   }
 487   virtual bool RemoveSendStream(uint32 ssrc) {
 488     send_formats_.erase(ssrc);
 489     return RtpHelper<VideoMediaChannel>::RemoveSendStream(ssrc);
 490   }
 491
 492   virtual bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
 493     if (fail_set_recv_codecs()) {
 494       // Fake the failure in SetRecvCodecs.
 495       return false;
 496     }
 497     recv_codecs_ = codecs;
 498     return true;
 499   }
 500   virtual bool SetSendCodecs(const std::vector<VideoCodec>& codecs) {
 501     if (fail_set_send_codecs()) {
 502       // Fake the failure in SetSendCodecs.
 503       return false;
 504     }
 505     send_codecs_ = codecs;
 506
 507     for (std::vector<StreamParams>::const_iterator it = send_streams().begin();
 508          it != send_streams().end(); ++it) {
 509       SetSendStreamDefaultFormat(it->first_ssrc());
 510     }
 511     return true;
 512   }
 513   virtual bool GetSendCodec(VideoCodec* send_codec) {
 514     if (send_codecs_.empty()) {
 515       return false;
 516     }
 517     *send_codec = send_codecs_[0];
 518     return true;
 519   }
 520   virtual bool SetRender(bool render) {
 521     set_playout(render);
 522     return true;
 523   }
 524   virtual bool SetRenderer(uint32 ssrc, VideoRenderer* r) {
 525     if (ssrc != 0 && renderers_.find(ssrc) == renderers_.end()) {
 526       return false;
 527     }
 528     if (ssrc != 0) {
 529       renderers_[ssrc] = r;
 530     }
 531     return true;
 532   }
 533
 534   virtual bool SetSend(bool send) { return set_sending(send); }
 535   virtual bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
 536     capturers_[ssrc] = capturer;
 537     return true;
 538   }
 539   bool HasCapturer(uint32 ssrc) const {
 540     return capturers_.find(ssrc) != capturers_.end();
 541   }
 542   virtual bool SetStartSendBandwidth(int bps) {
 543     start_bps_ = bps;
 544     return true;
 545   }
 546   virtual bool SetMaxSendBandwidth(int bps) {
 547     max_bps_ = bps;
 548     return true;
 549   }
 550   virtual bool AddRecvStream(const StreamParams& sp) {
 551     if (!RtpHelper<VideoMediaChannel>::AddRecvStream(sp))
 552       return false;
 553     renderers_[sp.first_ssrc()] = NULL;
 554     return true;
 555   }
 556   virtual bool RemoveRecvStream(uint32 ssrc) {
 557     if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
 558       return false;
 559     renderers_.erase(ssrc);
 560     return true;
 561   }
 562
 563   virtual bool GetStats(const StatsOptions& options,
 564                         VideoMediaInfo* info) { return false; }
 565   virtual bool SendIntraFrame() {
 566     sent_intra_frame_ = true;
 567     return true;
 568   }
 569   virtual bool RequestIntraFrame() {
 570     requested_intra_frame_ = true;
 571     return true;
 572   }
 573   virtual bool SetOptions(const VideoOptions& options) {
 574     options_ = options;
 575     return true;
 576   }
 577   virtual bool GetOptions(VideoOptions* options) const {
 578     *options = options_;
 579     return true;
 580   }
 581   virtual void UpdateAspectRatio(int ratio_w, int ratio_h) {}
 582   void set_sent_intra_frame(bool v) { sent_intra_frame_ = v; }
 583   bool sent_intra_frame() const { return sent_intra_frame_; }
 584   void set_requested_intra_frame(bool v) { requested_intra_frame_ = v; }
 585   bool requested_intra_frame() const { return requested_intra_frame_; }
 586
 587  private:
 588   // Be default, each send stream uses the first send codec format.
 589   void SetSendStreamDefaultFormat(uint32 ssrc) {
 590     if (!send_codecs_.empty()) {
 591       send_formats_[ssrc] = VideoFormat(
 592           send_codecs_[0].width, send_codecs_[0].height,
 593           cricket::VideoFormat::FpsToInterval(send_codecs_[0].framerate),
 594           cricket::FOURCC_I420);
 595     }
 596   }
 597
 598   FakeVideoEngine* engine_;
 599   std::vector<VideoCodec> recv_codecs_;
 600   std::vector<VideoCodec> send_codecs_;
 601   std::map<uint32, VideoRenderer*> renderers_;
 602   std::map<uint32, VideoFormat> send_formats_;
 603   std::map<uint32, VideoCapturer*> capturers_;
 604   bool sent_intra_frame_;
 605   bool requested_intra_frame_;
 606   VideoOptions options_;
 607   int start_bps_;
 608   int max_bps_;
 609 };
 610
 611 class FakeSoundclipMedia : public SoundclipMedia {
 612  public:
 613   virtual bool PlaySound(const char* buf, int len, int flags) { return true; }
 614 };
 615
 616 class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> {
 617  public:
 618   explicit FakeDataMediaChannel(void* unused)
 619       : send_blocked_(false), max_bps_(-1) {}
 620   ~FakeDataMediaChannel() {}
 621   const std::vector<DataCodec>& recv_codecs() const { return recv_codecs_; }
 622   const std::vector<DataCodec>& send_codecs() const { return send_codecs_; }
 623   const std::vector<DataCodec>& codecs() const { return send_codecs(); }
 624   int max_bps() const { return max_bps_; }
 625
 626   virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs) {
 627     if (fail_set_recv_codecs()) {
 628       // Fake the failure in SetRecvCodecs.
 629       return false;
 630     }
 631     recv_codecs_ = codecs;
 632     return true;
 633   }
 634   virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs) {
 635     if (fail_set_send_codecs()) {
 636       // Fake the failure in SetSendCodecs.
 637       return false;
 638     }
 639     send_codecs_ = codecs;
 640     return true;
 641   }
 642   virtual bool SetSend(bool send) { return set_sending(send); }
 643   virtual bool SetReceive(bool receive) {
 644     set_playout(receive);
 645     return true;
 646   }
 647   virtual bool SetStartSendBandwidth(int bps) { return true; }
 648   virtual bool SetMaxSendBandwidth(int bps) {
 649     max_bps_ = bps;
 650     return true;
 651   }
 652   virtual bool AddRecvStream(const StreamParams& sp) {
 653     if (!RtpHelper<DataMediaChannel>::AddRecvStream(sp))
 654       return false;
 655     return true;
 656   }
 657   virtual bool RemoveRecvStream(uint32 ssrc) {
 658     if (!RtpHelper<DataMediaChannel>::RemoveRecvStream(ssrc))
 659       return false;
 660     return true;
 661   }
 662
 663   virtual bool SendData(const SendDataParams& params,
 664                         const talk_base::Buffer& payload,
 665                         SendDataResult* result) {
 666     if (send_blocked_) {
 667       *result = SDR_BLOCK;
 668       return false;
 669     } else {
 670       last_sent_data_params_ = params;
 671       last_sent_data_ = std::string(payload.data(), payload.length());
 672       return true;
 673     }
 674   }
 675
 676   SendDataParams last_sent_data_params() { return last_sent_data_params_; }
 677   std::string last_sent_data() { return last_sent_data_; }
 678   bool is_send_blocked() { return send_blocked_; }
 679   void set_send_blocked(bool blocked) { send_blocked_ = blocked; }
 680
 681  private:
 682   std::vector<DataCodec> recv_codecs_;
 683   std::vector<DataCodec> send_codecs_;
 684   SendDataParams last_sent_data_params_;
 685   std::string last_sent_data_;
 686   bool send_blocked_;
 687   int max_bps_;
 688 };
 689
 690 // A base class for all of the shared parts between FakeVoiceEngine
 691 // and FakeVideoEngine.
 692 class FakeBaseEngine {
 693  public:
 694   FakeBaseEngine()
 695       : loglevel_(-1),
 696         options_changed_(false),
 697         fail_create_channel_(false) {}
 698   bool Init(talk_base::Thread* worker_thread) { return true; }
 699   void Terminate() {}
 700
 701   void SetLogging(int level, const char* filter) {
 702     loglevel_ = level;
 703     logfilter_ = filter;
 704   }
 705
 706   void set_fail_create_channel(bool fail) { fail_create_channel_ = fail; }
 707
 708   const std::vector<RtpHeaderExtension>& rtp_header_extensions() const {
 709     return rtp_header_extensions_;
 710   }
 711
 712  protected:
 713   int loglevel_;
 714   std::string logfilter_;
 715   // Flag used by optionsmessagehandler_unittest for checking whether any
 716   // relevant setting has been updated.
 717   // TODO(thaloun): Replace with explicit checks of before & after values.
 718   bool options_changed_;
 719   bool fail_create_channel_;
 720   std::vector<RtpHeaderExtension> rtp_header_extensions_;
 721 };
 722
 723 class FakeVoiceEngine : public FakeBaseEngine {
 724  public:
 725   FakeVoiceEngine()
 726       : output_volume_(-1),
 727         delay_offset_(0),
 728         rx_processor_(NULL),
 729         tx_processor_(NULL) {
 730     // Add a fake audio codec. Note that the name must not be "" as there are
 731     // sanity checks against that.
 732     codecs_.push_back(AudioCodec(101, "fake_audio_codec", 0, 0, 1, 0));
 733   }
 734   int GetCapabilities() { return AUDIO_SEND | AUDIO_RECV; }
 735   AudioOptions GetAudioOptions() const {
 736     return options_;
 737   }
 738   AudioOptions GetOptions() const {
 739     return options_;
 740   }
 741   bool SetOptions(const AudioOptions& options) {
 742     options_ = options;
 743     options_changed_ = true;
 744     return true;
 745   }
 746
 747   VoiceMediaChannel* CreateChannel() {
 748     if (fail_create_channel_) {
 749       return NULL;
 750     }
 751
 752     FakeVoiceMediaChannel* ch = new FakeVoiceMediaChannel(this);
 753     channels_.push_back(ch);
 754     return ch;
 755   }
 756   FakeVoiceMediaChannel* GetChannel(size_t index) {
 757     return (channels_.size() > index) ? channels_[index] : NULL;
 758   }
 759   void UnregisterChannel(VoiceMediaChannel* channel) {
 760     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
 761   }
 762   SoundclipMedia* CreateSoundclip() { return new FakeSoundclipMedia(); }
 763
 764   const std::vector<AudioCodec>& codecs() { return codecs_; }
 765   void SetCodecs(const std::vector<AudioCodec> codecs) { codecs_ = codecs; }
 766
 767   bool SetDelayOffset(int offset) {
 768     delay_offset_ = offset;
 769     return true;
 770   }
 771
 772   bool SetDevices(const Device* in_device, const Device* out_device) {
 773     in_device_ = (in_device) ? in_device->name : "";
 774     out_device_ = (out_device) ? out_device->name : "";
 775     options_changed_ = true;
 776     return true;
 777   }
 778
 779   bool GetOutputVolume(int* level) {
 780     *level = output_volume_;
 781     return true;
 782   }
 783
 784   bool SetOutputVolume(int level) {
 785     output_volume_ = level;
 786     options_changed_ = true;
 787     return true;
 788   }
 789
 790   int GetInputLevel() { return 0; }
 791
 792   bool SetLocalMonitor(bool enable) { return true; }
 793
 794   bool StartAecDump(talk_base::PlatformFile file) { return false; }
 795
 796   bool RegisterProcessor(uint32 ssrc, VoiceProcessor* voice_processor,
 797                          MediaProcessorDirection direction) {
 798     if (direction == MPD_RX) {
 799       rx_processor_ = voice_processor;
 800       return true;
 801     } else if (direction == MPD_TX) {
 802       tx_processor_ = voice_processor;
 803       return true;
 804     }
 805     return false;
 806   }
 807
 808   bool UnregisterProcessor(uint32 ssrc, VoiceProcessor* voice_processor,
 809                            MediaProcessorDirection direction) {
 810     bool unregistered = false;
 811     if (direction & MPD_RX) {
 812       rx_processor_ = NULL;
 813       unregistered = true;
 814     }
 815     if (direction & MPD_TX) {
 816       tx_processor_ = NULL;
 817       unregistered = true;
 818     }
 819     return unregistered;
 820   }
 821
 822  private:
 823   std::vector<FakeVoiceMediaChannel*> channels_;
 824   std::vector<AudioCodec> codecs_;
 825   int output_volume_;
 826   int delay_offset_;
 827   std::string in_device_;
 828   std::string out_device_;
 829   VoiceProcessor* rx_processor_;
 830   VoiceProcessor* tx_processor_;
 831   AudioOptions options_;
 832
 833   friend class FakeMediaEngine;
 834 };
 835
 836 class FakeVideoEngine : public FakeBaseEngine {
 837  public:
 838   FakeVideoEngine() : renderer_(NULL), capture_(false), processor_(NULL) {
 839     // Add a fake video codec. Note that the name must not be "" as there are
 840     // sanity checks against that.
 841     codecs_.push_back(VideoCodec(0, "fake_video_codec", 0, 0, 0, 0));
 842   }
 843   bool GetOptions(VideoOptions* options) const {
 844     *options = options_;
 845     return true;
 846   }
 847   bool SetOptions(const VideoOptions& options) {
 848     options_ = options;
 849     options_changed_ = true;
 850     return true;
 851   }
 852   int GetCapabilities() { return VIDEO_SEND | VIDEO_RECV; }
 853   bool SetDefaultEncoderConfig(const VideoEncoderConfig& config) {
 854     default_encoder_config_ = config;
 855     return true;
 856   }
 857   VideoEncoderConfig GetDefaultEncoderConfig() const {
 858     return default_encoder_config_;
 859   }
 860   const VideoEncoderConfig& default_encoder_config() const {
 861     return default_encoder_config_;
 862   }
 863
 864   VideoMediaChannel* CreateChannel(VoiceMediaChannel* channel) {
 865     if (fail_create_channel_) {
 866       return NULL;
 867     }
 868
 869     FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this);
 870     channels_.push_back(ch);
 871     return ch;
 872   }
 873   FakeVideoMediaChannel* GetChannel(size_t index) {
 874     return (channels_.size() > index) ? channels_[index] : NULL;
 875   }
 876   void UnregisterChannel(VideoMediaChannel* channel) {
 877     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
 878   }
 879
 880   const std::vector<VideoCodec>& codecs() const { return codecs_; }
 881   bool FindCodec(const VideoCodec& in) {
 882     for (size_t i = 0; i < codecs_.size(); ++i) {
 883       if (codecs_[i].Matches(in)) {
 884         return true;
 885       }
 886     }
 887     return false;
 888   }
 889   void SetCodecs(const std::vector<VideoCodec> codecs) { codecs_ = codecs; }
 890
 891   bool SetCaptureDevice(const Device* device) {
 892     in_device_ = (device) ? device->name : "";
 893     options_changed_ = true;
 894     return true;
 895   }
 896   bool SetLocalRenderer(VideoRenderer* r) {
 897     renderer_ = r;
 898     return true;
 899   }
 900   bool SetCapture(bool capture) {
 901     capture_ = capture;
 902     return true;
 903   }
 904   VideoFormat GetStartCaptureFormat() const {
 905     return VideoFormat(640, 480, cricket::VideoFormat::FpsToInterval(30),
 906                        FOURCC_I420);
 907   }
 908
 909   sigslot::repeater2<VideoCapturer*, CaptureState> SignalCaptureStateChange;
 910
 911  private:
 912   std::vector<FakeVideoMediaChannel*> channels_;
 913   std::vector<VideoCodec> codecs_;
 914   VideoEncoderConfig default_encoder_config_;
 915   std::string in_device_;
 916   VideoRenderer* renderer_;
 917   bool capture_;
 918   VideoProcessor* processor_;
 919   VideoOptions options_;
 920
 921   friend class FakeMediaEngine;
 922 };
 923
 924 class FakeMediaEngine :
 925     public CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine> {
 926  public:
 927   FakeMediaEngine() {
 928     voice_ = FakeVoiceEngine();
 929     video_ = FakeVideoEngine();
 930   }
 931   virtual ~FakeMediaEngine() {}
 932
 933   virtual void SetAudioCodecs(const std::vector<AudioCodec> codecs) {
 934     voice_.SetCodecs(codecs);
 935   }
 936
 937   virtual void SetVideoCodecs(const std::vector<VideoCodec> codecs) {
 938     video_.SetCodecs(codecs);
 939   }
 940
 941   FakeVoiceMediaChannel* GetVoiceChannel(size_t index) {
 942     return voice_.GetChannel(index);
 943   }
 944
 945   FakeVideoMediaChannel* GetVideoChannel(size_t index) {
 946     return video_.GetChannel(index);
 947   }
 948
 949   AudioOptions audio_options() const { return voice_.options_; }
 950   int audio_delay_offset() const { return voice_.delay_offset_; }
 951   int output_volume() const { return voice_.output_volume_; }
 952   const VideoEncoderConfig& default_video_encoder_config() const {
 953     return video_.default_encoder_config_;
 954   }
 955   const std::string& audio_in_device() const { return voice_.in_device_; }
 956   const std::string& audio_out_device() const { return voice_.out_device_; }
 957   VideoRenderer* local_renderer() { return video_.renderer_; }
 958   int voice_loglevel() const { return voice_.loglevel_; }
 959   const std::string& voice_logfilter() const { return voice_.logfilter_; }
 960   int video_loglevel() const { return video_.loglevel_; }
 961   const std::string& video_logfilter() const { return video_.logfilter_; }
 962   bool capture() const { return video_.capture_; }
 963   bool options_changed() const {
 964     return voice_.options_changed_ || video_.options_changed_;
 965   }
 966   void clear_options_changed() {
 967     video_.options_changed_ = false;
 968     voice_.options_changed_ = false;
 969   }
 970   void set_fail_create_channel(bool fail) {
 971     voice_.set_fail_create_channel(fail);
 972     video_.set_fail_create_channel(fail);
 973   }
 974   bool voice_processor_registered(MediaProcessorDirection direction) const {
 975     if (direction == MPD_RX) {
 976       return voice_.rx_processor_ != NULL;
 977     } else if (direction == MPD_TX) {
 978       return voice_.tx_processor_ != NULL;
 979     }
 980     return false;
 981   }
 982 };
 983
 984 // CompositeMediaEngine with FakeVoiceEngine to expose SetAudioCodecs to
 985 // establish a media connectionwith minimum set of audio codes required
 986 template <class VIDEO>
 987 class CompositeMediaEngineWithFakeVoiceEngine :
 988     public CompositeMediaEngine<FakeVoiceEngine, VIDEO> {
 989  public:
 990   CompositeMediaEngineWithFakeVoiceEngine() {}
 991   virtual ~CompositeMediaEngineWithFakeVoiceEngine() {}
 992
 993   virtual void SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
 994     CompositeMediaEngine<FakeVoiceEngine, VIDEO>::voice_.SetCodecs(codecs);
 995   }
 996 };
 997
 998 // Have to come afterwards due to declaration order
 999 inline FakeVoiceMediaChannel::~FakeVoiceMediaChannel() {
1000   if (engine_) {
1001     engine_->UnregisterChannel(this);
1002   }
1003 }
1004
1005 inline FakeVideoMediaChannel::~FakeVideoMediaChannel() {
1006   if (engine_) {
1007     engine_->UnregisterChannel(this);
1008   }
1009 }
1010
1011 class FakeDataEngine : public DataEngineInterface {
1012  public:
1013   FakeDataEngine() : last_channel_type_(DCT_NONE) {}
1014
1015   virtual DataMediaChannel* CreateChannel(DataChannelType data_channel_type) {
1016     last_channel_type_ = data_channel_type;
1017     FakeDataMediaChannel* ch = new FakeDataMediaChannel(this);
1018     channels_.push_back(ch);
1019     return ch;
1020   }
1021
1022   FakeDataMediaChannel* GetChannel(size_t index) {
1023     return (channels_.size() > index) ? channels_[index] : NULL;
1024   }
1025
1026   void UnregisterChannel(DataMediaChannel* channel) {
1027     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
1028   }
1029
1030   virtual void SetDataCodecs(const std::vector<DataCodec>& data_codecs) {
1031     data_codecs_ = data_codecs;
1032   }
1033
1034   virtual const std::vector<DataCodec>& data_codecs() { return data_codecs_; }
1035
1036   DataChannelType last_channel_type() const { return last_channel_type_; }
1037
1038  private:
1039   std::vector<FakeDataMediaChannel*> channels_;
1040   std::vector<DataCodec> data_codecs_;
1041   DataChannelType last_channel_type_;
1042 };
1043
1044 }  // namespace cricket
1045
1046 #endif  // TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_