Home | History | Annotate | Download | only in base 
      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 "talk/p2p/base/sessiondescription.h"
     42 #include "webrtc/base/buffer.h"
     43 #include "webrtc/base/stringutils.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     rtc::Buffer packet(data, len, kMaxRtpPacketLen);
     77     return Base::SendPacket(&packet);
     78   }
     79   bool SendRtcp(const void* data, int len) {
     80     rtc::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(rtc::Buffer* packet,
    195                                 const rtc::PacketTime& packet_time) {
    196     rtp_packets_.push_back(std::string(packet->data(), packet->length()));
    197   }
    198   virtual void OnRtcpReceived(rtc::Buffer* packet,
    199                               const rtc::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, VoiceChannelAudioSink*>::iterator it =
    320         local_renderers_.find(ssrc);
    321     if (renderer) {
    322       if (it != local_renderers_.end()) {
    323         ASSERT(it->second->renderer() == renderer);
    324       } else {
    325         local_renderers_.insert(std::make_pair(
    326             ssrc, new VoiceChannelAudioSink(renderer)));
    327       }
    328     } else {
    329       if (it != local_renderers_.end()) {
    330         delete it->second;
    331         local_renderers_.erase(it);
    332       } else {
    333         return false;
    334       }
    335     }
    336     return true;
    337   }
    338 
    339   virtual bool GetActiveStreams(AudioInfo::StreamList* streams) { return true; }
    340   virtual int GetOutputLevel() { return 0; }
    341   void set_time_since_last_typing(int ms) { time_since_last_typing_ = ms; }
    342   virtual int GetTimeSinceLastTyping() { return time_since_last_typing_; }
    343   virtual void SetTypingDetectionParameters(
    344       int time_window, int cost_per_typing, int reporting_threshold,
    345       int penalty_decay, int type_event_delay) {}
    346 
    347   virtual bool SetRingbackTone(const char* buf, int len) { return true; }
    348   virtual bool PlayRingbackTone(uint32 ssrc, bool play, bool loop) {
    349     ringback_tone_ssrc_ = ssrc;
    350     ringback_tone_play_ = play;
    351     ringback_tone_loop_ = loop;
    352     return true;
    353   }
    354 
    355   virtual bool CanInsertDtmf() {
    356     for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin();
    357          it != send_codecs_.end(); ++it) {
    358       // Find the DTMF telephone event "codec".
    359       if (_stricmp(it->name.c_str(), "telephone-event") == 0) {
    360         return true;
    361       }
    362     }
    363     return false;
    364   }
    365   virtual bool InsertDtmf(uint32 ssrc, int event_code, int duration,
    366                           int flags) {
    367     dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration, flags));
    368     return true;
    369   }
    370 
    371   virtual bool SetOutputScaling(uint32 ssrc, double left, double right) {
    372     if (0 == ssrc) {
    373       std::map<uint32, OutputScaling>::iterator it;
    374       for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) {
    375         it->second.left = left;
    376         it->second.right = right;
    377       }
    378       return true;
    379     } else if (output_scalings_.find(ssrc) != output_scalings_.end()) {
    380       output_scalings_[ssrc].left = left;
    381       output_scalings_[ssrc].right = right;
    382       return true;
    383     }
    384     return false;
    385   }
    386   virtual bool GetOutputScaling(uint32 ssrc, double* left, double* right) {
    387     if (output_scalings_.find(ssrc) == output_scalings_.end())
    388       return false;
    389     *left = output_scalings_[ssrc].left;
    390     *right = output_scalings_[ssrc].right;
    391     return true;
    392   }
    393 
    394   virtual bool GetStats(VoiceMediaInfo* info) { return false; }
    395   virtual void GetLastMediaError(uint32* ssrc,
    396                                  VoiceMediaChannel::Error* error) {
    397     *ssrc = 0;
    398     *error = fail_set_send_ ? VoiceMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED
    399                             : VoiceMediaChannel::ERROR_NONE;
    400   }
    401 
    402   void set_fail_set_send(bool fail) { fail_set_send_ = fail; }
    403   void TriggerError(uint32 ssrc, VoiceMediaChannel::Error error) {
    404     VoiceMediaChannel::SignalMediaError(ssrc, error);
    405   }
    406 
    407   virtual bool SetOptions(const AudioOptions& options) {
    408     // Does a "merge" of current options and set options.
    409     options_.SetAll(options);
    410     return true;
    411   }
    412   virtual bool GetOptions(AudioOptions* options) const {
    413     *options = options_;
    414     return true;
    415   }
    416 
    417  private:
    418   struct OutputScaling {
    419     OutputScaling() : left(1.0), right(1.0) {}
    420     double left, right;
    421   };
    422 
    423   class VoiceChannelAudioSink : public AudioRenderer::Sink {
    424    public:
    425     explicit VoiceChannelAudioSink(AudioRenderer* renderer)
    426         : renderer_(renderer) {
    427       renderer_->AddChannel(0);
    428       renderer_->SetSink(this);
    429     }
    430     virtual ~VoiceChannelAudioSink() {
    431       if (renderer_) {
    432         renderer_->RemoveChannel(0);
    433         renderer_->SetSink(NULL);
    434       }
    435     }
    436     virtual void OnData(const void* audio_data,
    437                         int bits_per_sample,
    438                         int sample_rate,
    439                         int number_of_channels,
    440                         int number_of_frames) OVERRIDE {}
    441     virtual void OnClose() OVERRIDE {
    442       renderer_ = NULL;
    443     }
    444     AudioRenderer* renderer() const { return renderer_; }
    445 
    446    private:
    447     AudioRenderer* renderer_;
    448   };
    449 
    450 
    451   FakeVoiceEngine* engine_;
    452   std::vector<AudioCodec> recv_codecs_;
    453   std::vector<AudioCodec> send_codecs_;
    454   std::map<uint32, OutputScaling> output_scalings_;
    455   std::vector<DtmfInfo> dtmf_info_queue_;
    456   bool fail_set_send_;
    457   uint32 ringback_tone_ssrc_;
    458   bool ringback_tone_play_;
    459   bool ringback_tone_loop_;
    460   int time_since_last_typing_;
    461   AudioOptions options_;
    462   std::map<uint32, VoiceChannelAudioSink*> local_renderers_;
    463   std::map<uint32, AudioRenderer*> remote_renderers_;
    464 };
    465 
    466 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo.
    467 inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
    468                             uint32 ssrc, int event_code, int duration,
    469                             int flags) {
    470   return (info.duration == duration && info.event_code == event_code &&
    471           info.flags == flags && info.ssrc == ssrc);
    472 }
    473 
    474 class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
    475  public:
    476   explicit FakeVideoMediaChannel(FakeVideoEngine* engine)
    477       : engine_(engine),
    478         sent_intra_frame_(false),
    479         requested_intra_frame_(false),
    480         start_bps_(-1),
    481         max_bps_(-1) {}
    482   ~FakeVideoMediaChannel();
    483 
    484   const std::vector<VideoCodec>& recv_codecs() const { return recv_codecs_; }
    485   const std::vector<VideoCodec>& send_codecs() const { return send_codecs_; }
    486   const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
    487   bool rendering() const { return playout(); }
    488   const VideoOptions& options() const { return options_; }
    489   const std::map<uint32, VideoRenderer*>& renderers() const {
    490     return renderers_;
    491   }
    492   int start_bps() const { return start_bps_; }
    493   int max_bps() const { return max_bps_; }
    494   bool GetSendStreamFormat(uint32 ssrc, VideoFormat* format) {
    495     if (send_formats_.find(ssrc) == send_formats_.end()) {
    496       return false;
    497     }
    498     *format = send_formats_[ssrc];
    499     return true;
    500   }
    501   virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) {
    502     if (send_formats_.find(ssrc) == send_formats_.end()) {
    503       return false;
    504     }
    505     send_formats_[ssrc] = format;
    506     return true;
    507   }
    508 
    509   virtual bool AddSendStream(const StreamParams& sp) {
    510     if (!RtpHelper<VideoMediaChannel>::AddSendStream(sp)) {
    511       return false;
    512     }
    513     SetSendStreamDefaultFormat(sp.first_ssrc());
    514     return true;
    515   }
    516   virtual bool RemoveSendStream(uint32 ssrc) {
    517     send_formats_.erase(ssrc);
    518     return RtpHelper<VideoMediaChannel>::RemoveSendStream(ssrc);
    519   }
    520 
    521   virtual bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
    522     if (fail_set_recv_codecs()) {
    523       // Fake the failure in SetRecvCodecs.
    524       return false;
    525     }
    526     recv_codecs_ = codecs;
    527     return true;
    528   }
    529   virtual bool SetSendCodecs(const std::vector<VideoCodec>& codecs) {
    530     if (fail_set_send_codecs()) {
    531       // Fake the failure in SetSendCodecs.
    532       return false;
    533     }
    534     send_codecs_ = codecs;
    535 
    536     for (std::vector<StreamParams>::const_iterator it = send_streams().begin();
    537          it != send_streams().end(); ++it) {
    538       SetSendStreamDefaultFormat(it->first_ssrc());
    539     }
    540     return true;
    541   }
    542   virtual bool GetSendCodec(VideoCodec* send_codec) {
    543     if (send_codecs_.empty()) {
    544       return false;
    545     }
    546     *send_codec = send_codecs_[0];
    547     return true;
    548   }
    549   virtual bool SetRender(bool render) {
    550     set_playout(render);
    551     return true;
    552   }
    553   virtual bool SetRenderer(uint32 ssrc, VideoRenderer* r) {
    554     if (ssrc != 0 && renderers_.find(ssrc) == renderers_.end()) {
    555       return false;
    556     }
    557     if (ssrc != 0) {
    558       renderers_[ssrc] = r;
    559     }
    560     return true;
    561   }
    562 
    563   virtual bool SetSend(bool send) { return set_sending(send); }
    564   virtual bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
    565     capturers_[ssrc] = capturer;
    566     return true;
    567   }
    568   bool HasCapturer(uint32 ssrc) const {
    569     return capturers_.find(ssrc) != capturers_.end();
    570   }
    571   virtual bool SetStartSendBandwidth(int bps) {
    572     start_bps_ = bps;
    573     return true;
    574   }
    575   virtual bool SetMaxSendBandwidth(int bps) {
    576     max_bps_ = bps;
    577     return true;
    578   }
    579   virtual bool AddRecvStream(const StreamParams& sp) {
    580     if (!RtpHelper<VideoMediaChannel>::AddRecvStream(sp))
    581       return false;
    582     renderers_[sp.first_ssrc()] = NULL;
    583     return true;
    584   }
    585   virtual bool RemoveRecvStream(uint32 ssrc) {
    586     if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
    587       return false;
    588     renderers_.erase(ssrc);
    589     return true;
    590   }
    591 
    592   virtual bool GetStats(const StatsOptions& options,
    593                         VideoMediaInfo* info) { return false; }
    594   virtual bool SendIntraFrame() {
    595     sent_intra_frame_ = true;
    596     return true;
    597   }
    598   virtual bool RequestIntraFrame() {
    599     requested_intra_frame_ = true;
    600     return true;
    601   }
    602   virtual bool SetOptions(const VideoOptions& options) {
    603     options_ = options;
    604     return true;
    605   }
    606   virtual bool GetOptions(VideoOptions* options) const {
    607     *options = options_;
    608     return true;
    609   }
    610   virtual void UpdateAspectRatio(int ratio_w, int ratio_h) {}
    611   void set_sent_intra_frame(bool v) { sent_intra_frame_ = v; }
    612   bool sent_intra_frame() const { return sent_intra_frame_; }
    613   void set_requested_intra_frame(bool v) { requested_intra_frame_ = v; }
    614   bool requested_intra_frame() const { return requested_intra_frame_; }
    615 
    616  private:
    617   // Be default, each send stream uses the first send codec format.
    618   void SetSendStreamDefaultFormat(uint32 ssrc) {
    619     if (!send_codecs_.empty()) {
    620       send_formats_[ssrc] = VideoFormat(
    621           send_codecs_[0].width, send_codecs_[0].height,
    622           cricket::VideoFormat::FpsToInterval(send_codecs_[0].framerate),
    623           cricket::FOURCC_I420);
    624     }
    625   }
    626 
    627   FakeVideoEngine* engine_;
    628   std::vector<VideoCodec> recv_codecs_;
    629   std::vector<VideoCodec> send_codecs_;
    630   std::map<uint32, VideoRenderer*> renderers_;
    631   std::map<uint32, VideoFormat> send_formats_;
    632   std::map<uint32, VideoCapturer*> capturers_;
    633   bool sent_intra_frame_;
    634   bool requested_intra_frame_;
    635   VideoOptions options_;
    636   int start_bps_;
    637   int max_bps_;
    638 };
    639 
    640 class FakeSoundclipMedia : public SoundclipMedia {
    641  public:
    642   virtual bool PlaySound(const char* buf, int len, int flags) { return true; }
    643 };
    644 
    645 class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> {
    646  public:
    647   explicit FakeDataMediaChannel(void* unused)
    648       : send_blocked_(false), max_bps_(-1) {}
    649   ~FakeDataMediaChannel() {}
    650   const std::vector<DataCodec>& recv_codecs() const { return recv_codecs_; }
    651   const std::vector<DataCodec>& send_codecs() const { return send_codecs_; }
    652   const std::vector<DataCodec>& codecs() const { return send_codecs(); }
    653   int max_bps() const { return max_bps_; }
    654 
    655   virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs) {
    656     if (fail_set_recv_codecs()) {
    657       // Fake the failure in SetRecvCodecs.
    658       return false;
    659     }
    660     recv_codecs_ = codecs;
    661     return true;
    662   }
    663   virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs) {
    664     if (fail_set_send_codecs()) {
    665       // Fake the failure in SetSendCodecs.
    666       return false;
    667     }
    668     send_codecs_ = codecs;
    669     return true;
    670   }
    671   virtual bool SetSend(bool send) { return set_sending(send); }
    672   virtual bool SetReceive(bool receive) {
    673     set_playout(receive);
    674     return true;
    675   }
    676   virtual bool SetStartSendBandwidth(int bps) { return true; }
    677   virtual bool SetMaxSendBandwidth(int bps) {
    678     max_bps_ = bps;
    679     return true;
    680   }
    681   virtual bool AddRecvStream(const StreamParams& sp) {
    682     if (!RtpHelper<DataMediaChannel>::AddRecvStream(sp))
    683       return false;
    684     return true;
    685   }
    686   virtual bool RemoveRecvStream(uint32 ssrc) {
    687     if (!RtpHelper<DataMediaChannel>::RemoveRecvStream(ssrc))
    688       return false;
    689     return true;
    690   }
    691 
    692   virtual bool SendData(const SendDataParams& params,
    693                         const rtc::Buffer& payload,
    694                         SendDataResult* result) {
    695     if (send_blocked_) {
    696       *result = SDR_BLOCK;
    697       return false;
    698     } else {
    699       last_sent_data_params_ = params;
    700       last_sent_data_ = std::string(payload.data(), payload.length());
    701       return true;
    702     }
    703   }
    704 
    705   SendDataParams last_sent_data_params() { return last_sent_data_params_; }
    706   std::string last_sent_data() { return last_sent_data_; }
    707   bool is_send_blocked() { return send_blocked_; }
    708   void set_send_blocked(bool blocked) { send_blocked_ = blocked; }
    709 
    710  private:
    711   std::vector<DataCodec> recv_codecs_;
    712   std::vector<DataCodec> send_codecs_;
    713   SendDataParams last_sent_data_params_;
    714   std::string last_sent_data_;
    715   bool send_blocked_;
    716   int max_bps_;
    717 };
    718 
    719 // A base class for all of the shared parts between FakeVoiceEngine
    720 // and FakeVideoEngine.
    721 class FakeBaseEngine {
    722  public:
    723   FakeBaseEngine()
    724       : loglevel_(-1),
    725         options_changed_(false),
    726         fail_create_channel_(false) {}
    727   bool Init(rtc::Thread* worker_thread) { return true; }
    728   void Terminate() {}
    729 
    730   void SetLogging(int level, const char* filter) {
    731     loglevel_ = level;
    732     logfilter_ = filter;
    733   }
    734 
    735   void set_fail_create_channel(bool fail) { fail_create_channel_ = fail; }
    736 
    737   const std::vector<RtpHeaderExtension>& rtp_header_extensions() const {
    738     return rtp_header_extensions_;
    739   }
    740   void set_rtp_header_extensions(
    741       const std::vector<RtpHeaderExtension>& extensions) {
    742     rtp_header_extensions_ = extensions;
    743   }
    744 
    745  protected:
    746   int loglevel_;
    747   std::string logfilter_;
    748   // Flag used by optionsmessagehandler_unittest for checking whether any
    749   // relevant setting has been updated.
    750   // TODO(thaloun): Replace with explicit checks of before & after values.
    751   bool options_changed_;
    752   bool fail_create_channel_;
    753   std::vector<RtpHeaderExtension> rtp_header_extensions_;
    754 };
    755 
    756 class FakeVoiceEngine : public FakeBaseEngine {
    757  public:
    758   FakeVoiceEngine()
    759       : output_volume_(-1),
    760         delay_offset_(0),
    761         rx_processor_(NULL),
    762         tx_processor_(NULL) {
    763     // Add a fake audio codec. Note that the name must not be "" as there are
    764     // sanity checks against that.
    765     codecs_.push_back(AudioCodec(101, "fake_audio_codec", 0, 0, 1, 0));
    766   }
    767   int GetCapabilities() { return AUDIO_SEND | AUDIO_RECV; }
    768   AudioOptions GetAudioOptions() const {
    769     return options_;
    770   }
    771   AudioOptions GetOptions() const {
    772     return options_;
    773   }
    774   bool SetOptions(const AudioOptions& options) {
    775     options_ = options;
    776     options_changed_ = true;
    777     return true;
    778   }
    779 
    780   VoiceMediaChannel* CreateChannel() {
    781     if (fail_create_channel_) {
    782       return NULL;
    783     }
    784 
    785     FakeVoiceMediaChannel* ch = new FakeVoiceMediaChannel(this);
    786     channels_.push_back(ch);
    787     return ch;
    788   }
    789   FakeVoiceMediaChannel* GetChannel(size_t index) {
    790     return (channels_.size() > index) ? channels_[index] : NULL;
    791   }
    792   void UnregisterChannel(VoiceMediaChannel* channel) {
    793     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
    794   }
    795   SoundclipMedia* CreateSoundclip() { return new FakeSoundclipMedia(); }
    796 
    797   const std::vector<AudioCodec>& codecs() { return codecs_; }
    798   void SetCodecs(const std::vector<AudioCodec> codecs) { codecs_ = codecs; }
    799 
    800   bool SetDelayOffset(int offset) {
    801     delay_offset_ = offset;
    802     return true;
    803   }
    804 
    805   bool SetDevices(const Device* in_device, const Device* out_device) {
    806     in_device_ = (in_device) ? in_device->name : "";
    807     out_device_ = (out_device) ? out_device->name : "";
    808     options_changed_ = true;
    809     return true;
    810   }
    811 
    812   bool GetOutputVolume(int* level) {
    813     *level = output_volume_;
    814     return true;
    815   }
    816 
    817   bool SetOutputVolume(int level) {
    818     output_volume_ = level;
    819     options_changed_ = true;
    820     return true;
    821   }
    822 
    823   int GetInputLevel() { return 0; }
    824 
    825   bool SetLocalMonitor(bool enable) { return true; }
    826 
    827   bool StartAecDump(rtc::PlatformFile file) { return false; }
    828 
    829   bool RegisterProcessor(uint32 ssrc, VoiceProcessor* voice_processor,
    830                          MediaProcessorDirection direction) {
    831     if (direction == MPD_RX) {
    832       rx_processor_ = voice_processor;
    833       return true;
    834     } else if (direction == MPD_TX) {
    835       tx_processor_ = voice_processor;
    836       return true;
    837     }
    838     return false;
    839   }
    840 
    841   bool UnregisterProcessor(uint32 ssrc, VoiceProcessor* voice_processor,
    842                            MediaProcessorDirection direction) {
    843     bool unregistered = false;
    844     if (direction & MPD_RX) {
    845       rx_processor_ = NULL;
    846       unregistered = true;
    847     }
    848     if (direction & MPD_TX) {
    849       tx_processor_ = NULL;
    850       unregistered = true;
    851     }
    852     return unregistered;
    853   }
    854 
    855  private:
    856   std::vector<FakeVoiceMediaChannel*> channels_;
    857   std::vector<AudioCodec> codecs_;
    858   int output_volume_;
    859   int delay_offset_;
    860   std::string in_device_;
    861   std::string out_device_;
    862   VoiceProcessor* rx_processor_;
    863   VoiceProcessor* tx_processor_;
    864   AudioOptions options_;
    865 
    866   friend class FakeMediaEngine;
    867 };
    868 
    869 class FakeVideoEngine : public FakeBaseEngine {
    870  public:
    871   FakeVideoEngine() : capture_(false), processor_(NULL) {
    872     // Add a fake video codec. Note that the name must not be "" as there are
    873     // sanity checks against that.
    874     codecs_.push_back(VideoCodec(0, "fake_video_codec", 0, 0, 0, 0));
    875   }
    876   bool GetOptions(VideoOptions* options) const {
    877     *options = options_;
    878     return true;
    879   }
    880   bool SetOptions(const VideoOptions& options) {
    881     options_ = options;
    882     options_changed_ = true;
    883     return true;
    884   }
    885   int GetCapabilities() { return VIDEO_SEND | VIDEO_RECV; }
    886   bool SetDefaultEncoderConfig(const VideoEncoderConfig& config) {
    887     default_encoder_config_ = config;
    888     return true;
    889   }
    890   VideoEncoderConfig GetDefaultEncoderConfig() const {
    891     return default_encoder_config_;
    892   }
    893   const VideoEncoderConfig& default_encoder_config() const {
    894     return default_encoder_config_;
    895   }
    896 
    897   VideoMediaChannel* CreateChannel(VoiceMediaChannel* channel) {
    898     if (fail_create_channel_) {
    899       return NULL;
    900     }
    901 
    902     FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this);
    903     channels_.push_back(ch);
    904     return ch;
    905   }
    906   FakeVideoMediaChannel* GetChannel(size_t index) {
    907     return (channels_.size() > index) ? channels_[index] : NULL;
    908   }
    909   void UnregisterChannel(VideoMediaChannel* channel) {
    910     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
    911   }
    912 
    913   const std::vector<VideoCodec>& codecs() const { return codecs_; }
    914   bool FindCodec(const VideoCodec& in) {
    915     for (size_t i = 0; i < codecs_.size(); ++i) {
    916       if (codecs_[i].Matches(in)) {
    917         return true;
    918       }
    919     }
    920     return false;
    921   }
    922   void SetCodecs(const std::vector<VideoCodec> codecs) { codecs_ = codecs; }
    923 
    924   bool SetCaptureDevice(const Device* device) {
    925     in_device_ = (device) ? device->name : "";
    926     options_changed_ = true;
    927     return true;
    928   }
    929   bool SetCapture(bool capture) {
    930     capture_ = capture;
    931     return true;
    932   }
    933   VideoFormat GetStartCaptureFormat() const {
    934     return VideoFormat(640, 480, cricket::VideoFormat::FpsToInterval(30),
    935                        FOURCC_I420);
    936   }
    937 
    938   sigslot::repeater2<VideoCapturer*, CaptureState> SignalCaptureStateChange;
    939 
    940  private:
    941   std::vector<FakeVideoMediaChannel*> channels_;
    942   std::vector<VideoCodec> codecs_;
    943   VideoEncoderConfig default_encoder_config_;
    944   std::string in_device_;
    945   bool capture_;
    946   VideoProcessor* processor_;
    947   VideoOptions options_;
    948 
    949   friend class FakeMediaEngine;
    950 };
    951 
    952 class FakeMediaEngine :
    953     public CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine> {
    954  public:
    955   FakeMediaEngine() {
    956     voice_ = FakeVoiceEngine();
    957     video_ = FakeVideoEngine();
    958   }
    959   virtual ~FakeMediaEngine() {}
    960 
    961   void SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
    962     voice_.SetCodecs(codecs);
    963   }
    964   void SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
    965     video_.SetCodecs(codecs);
    966   }
    967 
    968   void SetAudioRtpHeaderExtensions(
    969       const std::vector<RtpHeaderExtension>& extensions) {
    970     voice_.set_rtp_header_extensions(extensions);
    971   }
    972   void SetVideoRtpHeaderExtensions(
    973       const std::vector<RtpHeaderExtension>& extensions) {
    974     video_.set_rtp_header_extensions(extensions);
    975   }
    976 
    977   FakeVoiceMediaChannel* GetVoiceChannel(size_t index) {
    978     return voice_.GetChannel(index);
    979   }
    980   FakeVideoMediaChannel* GetVideoChannel(size_t index) {
    981     return video_.GetChannel(index);
    982   }
    983 
    984   AudioOptions audio_options() const { return voice_.options_; }
    985   int audio_delay_offset() const { return voice_.delay_offset_; }
    986   int output_volume() const { return voice_.output_volume_; }
    987   const VideoEncoderConfig& default_video_encoder_config() const {
    988     return video_.default_encoder_config_;
    989   }
    990   const std::string& audio_in_device() const { return voice_.in_device_; }
    991   const std::string& audio_out_device() const { return voice_.out_device_; }
    992   int voice_loglevel() const { return voice_.loglevel_; }
    993   const std::string& voice_logfilter() const { return voice_.logfilter_; }
    994   int video_loglevel() const { return video_.loglevel_; }
    995   const std::string& video_logfilter() const { return video_.logfilter_; }
    996   bool capture() const { return video_.capture_; }
    997   bool options_changed() const {
    998     return voice_.options_changed_ || video_.options_changed_;
    999   }
   1000   void clear_options_changed() {
   1001     video_.options_changed_ = false;
   1002     voice_.options_changed_ = false;
   1003   }
   1004   void set_fail_create_channel(bool fail) {
   1005     voice_.set_fail_create_channel(fail);
   1006     video_.set_fail_create_channel(fail);
   1007   }
   1008   bool voice_processor_registered(MediaProcessorDirection direction) const {
   1009     if (direction == MPD_RX) {
   1010       return voice_.rx_processor_ != NULL;
   1011     } else if (direction == MPD_TX) {
   1012       return voice_.tx_processor_ != NULL;
   1013     }
   1014     return false;
   1015   }
   1016 };
   1017 
   1018 // CompositeMediaEngine with FakeVoiceEngine to expose SetAudioCodecs to
   1019 // establish a media connectionwith minimum set of audio codes required
   1020 template <class VIDEO>
   1021 class CompositeMediaEngineWithFakeVoiceEngine :
   1022     public CompositeMediaEngine<FakeVoiceEngine, VIDEO> {
   1023  public:
   1024   CompositeMediaEngineWithFakeVoiceEngine() {}
   1025   virtual ~CompositeMediaEngineWithFakeVoiceEngine() {}
   1026 
   1027   virtual void SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
   1028     CompositeMediaEngine<FakeVoiceEngine, VIDEO>::voice_.SetCodecs(codecs);
   1029   }
   1030 };
   1031 
   1032 // Have to come afterwards due to declaration order
   1033 inline FakeVoiceMediaChannel::~FakeVoiceMediaChannel() {
   1034   if (engine_) {
   1035     engine_->UnregisterChannel(this);
   1036   }
   1037 }
   1038 
   1039 inline FakeVideoMediaChannel::~FakeVideoMediaChannel() {
   1040   if (engine_) {
   1041     engine_->UnregisterChannel(this);
   1042   }
   1043 }
   1044 
   1045 class FakeDataEngine : public DataEngineInterface {
   1046  public:
   1047   FakeDataEngine() : last_channel_type_(DCT_NONE) {}
   1048 
   1049   virtual DataMediaChannel* CreateChannel(DataChannelType data_channel_type) {
   1050     last_channel_type_ = data_channel_type;
   1051     FakeDataMediaChannel* ch = new FakeDataMediaChannel(this);
   1052     channels_.push_back(ch);
   1053     return ch;
   1054   }
   1055 
   1056   FakeDataMediaChannel* GetChannel(size_t index) {
   1057     return (channels_.size() > index) ? channels_[index] : NULL;
   1058   }
   1059 
   1060   void UnregisterChannel(DataMediaChannel* channel) {
   1061     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
   1062   }
   1063 
   1064   virtual void SetDataCodecs(const std::vector<DataCodec>& data_codecs) {
   1065     data_codecs_ = data_codecs;
   1066   }
   1067 
   1068   virtual const std::vector<DataCodec>& data_codecs() { return data_codecs_; }
   1069 
   1070   DataChannelType last_channel_type() const { return last_channel_type_; }
   1071 
   1072  private:
   1073   std::vector<FakeDataMediaChannel*> channels_;
   1074   std::vector<DataCodec> data_codecs_;
   1075   DataChannelType last_channel_type_;
   1076 };
   1077 
   1078 }  // namespace cricket
   1079 
   1080 #endif  // TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_
   1081