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_FAKENETWORKINTERFACE_H_
29#define TALK_MEDIA_BASE_FAKENETWORKINTERFACE_H_
30
31#include <map>
32#include <vector>
33
34#include "talk/media/base/mediachannel.h"
35#include "talk/media/base/rtputils.h"
36#include "webrtc/base/buffer.h"
37#include "webrtc/base/byteorder.h"
38#include "webrtc/base/criticalsection.h"
39#include "webrtc/base/dscp.h"
40#include "webrtc/base/messagehandler.h"
41#include "webrtc/base/messagequeue.h"
42#include "webrtc/base/thread.h"
43
44namespace cricket {
45
46// Fake NetworkInterface that sends/receives RTP/RTCP packets.
47class FakeNetworkInterface : public MediaChannel::NetworkInterface,
48                             public rtc::MessageHandler {
49 public:
50  FakeNetworkInterface()
51      : thread_(rtc::Thread::Current()),
52        dest_(NULL),
53        conf_(false),
54        sendbuf_size_(-1),
55        recvbuf_size_(-1),
56        dscp_(rtc::DSCP_NO_CHANGE) {
57  }
58
59  void SetDestination(MediaChannel* dest) { dest_ = dest; }
60
61  // Conference mode is a mode where instead of simply forwarding the packets,
62  // the transport will send multiple copies of the packet with the specified
63  // SSRCs. This allows us to simulate receiving media from multiple sources.
64  void SetConferenceMode(bool conf, const std::vector<uint32>& ssrcs) {
65    rtc::CritScope cs(&crit_);
66    conf_ = conf;
67    conf_sent_ssrcs_ = ssrcs;
68  }
69
70  int NumRtpBytes() {
71    rtc::CritScope cs(&crit_);
72    int bytes = 0;
73    for (size_t i = 0; i < rtp_packets_.size(); ++i) {
74      bytes += static_cast<int>(rtp_packets_[i].length());
75    }
76    return bytes;
77  }
78
79  int NumRtpBytes(uint32 ssrc) {
80    rtc::CritScope cs(&crit_);
81    int bytes = 0;
82    GetNumRtpBytesAndPackets(ssrc, &bytes, NULL);
83    return bytes;
84  }
85
86  int NumRtpPackets() {
87    rtc::CritScope cs(&crit_);
88    return static_cast<int>(rtp_packets_.size());
89  }
90
91  int NumRtpPackets(uint32 ssrc) {
92    rtc::CritScope cs(&crit_);
93    int packets = 0;
94    GetNumRtpBytesAndPackets(ssrc, NULL, &packets);
95    return packets;
96  }
97
98  int NumSentSsrcs() {
99    rtc::CritScope cs(&crit_);
100    return static_cast<int>(sent_ssrcs_.size());
101  }
102
103  // Note: callers are responsible for deleting the returned buffer.
104  const rtc::Buffer* GetRtpPacket(int index) {
105    rtc::CritScope cs(&crit_);
106    if (index >= NumRtpPackets()) {
107      return NULL;
108    }
109    return new rtc::Buffer(rtp_packets_[index]);
110  }
111
112  int NumRtcpPackets() {
113    rtc::CritScope cs(&crit_);
114    return static_cast<int>(rtcp_packets_.size());
115  }
116
117  // Note: callers are responsible for deleting the returned buffer.
118  const rtc::Buffer* GetRtcpPacket(int index) {
119    rtc::CritScope cs(&crit_);
120    if (index >= NumRtcpPackets()) {
121      return NULL;
122    }
123    return new rtc::Buffer(rtcp_packets_[index]);
124  }
125
126  // Indicate that |n|'th packet for |ssrc| should be dropped.
127  void AddPacketDrop(uint32 ssrc, uint32 n) {
128    drop_map_[ssrc].insert(n);
129  }
130
131  int sendbuf_size() const { return sendbuf_size_; }
132  int recvbuf_size() const { return recvbuf_size_; }
133  rtc::DiffServCodePoint dscp() const { return dscp_; }
134
135 protected:
136  virtual bool SendPacket(rtc::Buffer* packet,
137                          rtc::DiffServCodePoint dscp) {
138    rtc::CritScope cs(&crit_);
139
140    uint32 cur_ssrc = 0;
141    if (!GetRtpSsrc(packet->data(), packet->length(), &cur_ssrc)) {
142      return false;
143    }
144    sent_ssrcs_[cur_ssrc]++;
145
146    // Check if we need to drop this packet.
147    std::map<uint32, std::set<uint32> >::iterator itr =
148      drop_map_.find(cur_ssrc);
149    if (itr != drop_map_.end() &&
150        itr->second.count(sent_ssrcs_[cur_ssrc]) > 0) {
151        // "Drop" the packet.
152        return true;
153    }
154
155    rtp_packets_.push_back(*packet);
156    if (conf_) {
157      rtc::Buffer buffer_copy(*packet);
158      for (size_t i = 0; i < conf_sent_ssrcs_.size(); ++i) {
159        if (!SetRtpSsrc(buffer_copy.data(), buffer_copy.length(),
160                        conf_sent_ssrcs_[i])) {
161          return false;
162        }
163        PostMessage(ST_RTP, buffer_copy);
164      }
165    } else {
166      PostMessage(ST_RTP, *packet);
167    }
168    return true;
169  }
170
171  virtual bool SendRtcp(rtc::Buffer* packet,
172                        rtc::DiffServCodePoint dscp) {
173    rtc::CritScope cs(&crit_);
174    rtcp_packets_.push_back(*packet);
175    if (!conf_) {
176      // don't worry about RTCP in conf mode for now
177      PostMessage(ST_RTCP, *packet);
178    }
179    return true;
180  }
181
182  virtual int SetOption(SocketType type, rtc::Socket::Option opt,
183                        int option) {
184    if (opt == rtc::Socket::OPT_SNDBUF) {
185      sendbuf_size_ = option;
186    } else if (opt == rtc::Socket::OPT_RCVBUF) {
187      recvbuf_size_ = option;
188    } else if (opt == rtc::Socket::OPT_DSCP) {
189      dscp_ = static_cast<rtc::DiffServCodePoint>(option);
190    }
191    return 0;
192  }
193
194  void PostMessage(int id, const rtc::Buffer& packet) {
195    thread_->Post(this, id, rtc::WrapMessageData(packet));
196  }
197
198  virtual void OnMessage(rtc::Message* msg) {
199    rtc::TypedMessageData<rtc::Buffer>* msg_data =
200        static_cast<rtc::TypedMessageData<rtc::Buffer>*>(
201            msg->pdata);
202    if (dest_) {
203      if (msg->message_id == ST_RTP) {
204        dest_->OnPacketReceived(&msg_data->data(),
205                                rtc::CreatePacketTime(0));
206      } else {
207        dest_->OnRtcpReceived(&msg_data->data(),
208                              rtc::CreatePacketTime(0));
209      }
210    }
211    delete msg_data;
212  }
213
214 private:
215  void GetNumRtpBytesAndPackets(uint32 ssrc, int* bytes, int* packets) {
216    if (bytes) {
217      *bytes = 0;
218    }
219    if (packets) {
220      *packets = 0;
221    }
222    uint32 cur_ssrc = 0;
223    for (size_t i = 0; i < rtp_packets_.size(); ++i) {
224      if (!GetRtpSsrc(rtp_packets_[i].data(),
225                      rtp_packets_[i].length(), &cur_ssrc)) {
226        return;
227      }
228      if (ssrc == cur_ssrc) {
229        if (bytes) {
230          *bytes += static_cast<int>(rtp_packets_[i].length());
231        }
232        if (packets) {
233          ++(*packets);
234        }
235      }
236    }
237  }
238
239  rtc::Thread* thread_;
240  MediaChannel* dest_;
241  bool conf_;
242  // The ssrcs used in sending out packets in conference mode.
243  std::vector<uint32> conf_sent_ssrcs_;
244  // Map to track counts of packets that have been sent per ssrc.
245  // This includes packets that are dropped.
246  std::map<uint32, uint32> sent_ssrcs_;
247  // Map to track packet-number that needs to be dropped per ssrc.
248  std::map<uint32, std::set<uint32> > drop_map_;
249  rtc::CriticalSection crit_;
250  std::vector<rtc::Buffer> rtp_packets_;
251  std::vector<rtc::Buffer> rtcp_packets_;
252  int sendbuf_size_;
253  int recvbuf_size_;
254  rtc::DiffServCodePoint dscp_;
255};
256
257}  // namespace cricket
258
259#endif  // TALK_MEDIA_BASE_FAKENETWORKINTERFACE_H_
260