src/third_party/webrtc/video_engine/test/libvietest/include/tb_external_transport.h

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 //
  12 // tb_external_transport.h
  13 //
  14
  15 #ifndef WEBRTC_VIDEO_ENGINE_TEST_AUTOTEST_INTERFACE_TB_EXTERNAL_TRANSPORT_H_
  16 #define WEBRTC_VIDEO_ENGINE_TEST_AUTOTEST_INTERFACE_TB_EXTERNAL_TRANSPORT_H_
  17
  18 #include <list>
  19 #include <map>
  20
  21 #include "webrtc/common_types.h"
  22
  23 namespace webrtc
  24 {
  25 class CriticalSectionWrapper;
  26 class EventWrapper;
  27 class ThreadWrapper;
  28 class ViENetwork;
  29 }
  30
  31 enum RandomLossModel {
  32   kNoLoss,
  33   kUniformLoss,
  34   kGilbertElliotLoss
  35 };
  36 struct NetworkParameters {
  37   int packet_loss_rate;
  38   int burst_length;  // Only applicable for kGilbertElliotLoss.
  39   int mean_one_way_delay;
  40   int std_dev_one_way_delay;
  41   RandomLossModel loss_model;
  42   NetworkParameters():
  43     packet_loss_rate(0), burst_length(0), mean_one_way_delay(0),
  44         std_dev_one_way_delay(0), loss_model(kNoLoss) {}
  45 };
  46
  47 // Allows to subscribe for callback when a frame is started being sent.
  48 class SendFrameCallback
  49 {
  50 public:
  51     // Called once per frame (when a new RTP timestamp is detected) when the
  52     // first data packet of the frame is being sent using the
  53     // TbExternalTransport.SendPacket method.
  54     virtual void FrameSent(unsigned int rtp_timestamp) = 0;
  55 protected:
  56     SendFrameCallback() {}
  57     virtual ~SendFrameCallback() {}
  58 };
  59
  60 // Allows to subscribe for callback when the first packet of a frame is
  61 // received.
  62 class ReceiveFrameCallback
  63 {
  64 public:
  65     // Called once per frame (when a new RTP timestamp is detected)
  66     // during the processing of the RTP packet queue in
  67     // TbExternalTransport::ViEExternalTransportProcess.
  68     virtual void FrameReceived(unsigned int rtp_timestamp) = 0;
  69 protected:
  70     ReceiveFrameCallback() {}
  71     virtual ~ReceiveFrameCallback() {}
  72 };
  73
  74 // External transport implementation for testing purposes.
  75 // A packet loss probability must be set in order to drop packets from the data
  76 // being sent to this class.
  77 // Will never drop packets from the first frame of a video sequence.
  78 class TbExternalTransport : public webrtc::Transport
  79 {
  80 public:
  81     typedef std::map<unsigned int, unsigned int> SsrcChannelMap;
  82
  83     TbExternalTransport(webrtc::ViENetwork& vieNetwork,
  84                         int sender_channel,
  85                         TbExternalTransport::SsrcChannelMap* receive_channels);
  86     ~TbExternalTransport(void);
  87
  88     virtual int SendPacket(int channel, const void *data, int len) OVERRIDE;
  89     virtual int SendRTCPPacket(int channel, const void *data, int len) OVERRIDE;
  90
  91     // Should only be called before/after traffic is being processed.
  92     // Only one observer can be set (multiple calls will overwrite each other).
  93     virtual void RegisterSendFrameCallback(SendFrameCallback* callback);
  94
  95     // Should only be called before/after traffic is being processed.
  96     // Only one observer can be set (multiple calls will overwrite each other).
  97     virtual void RegisterReceiveFrameCallback(ReceiveFrameCallback* callback);
  98
  99     // The network parameters of the link. Regarding packet losses, packets
 100     // belonging to the first frame (same RTP timestamp) will never be dropped.
 101     void SetNetworkParameters(const NetworkParameters& network_parameters);
 102     void SetSSRCFilter(uint32_t SSRC);
 103
 104     void ClearStats();
 105     // |packet_counters| is a map which counts the number of packets sent per
 106     // payload type.
 107     void GetStats(int32_t& numRtpPackets,
 108                   int32_t& numDroppedPackets,
 109                   int32_t& numRtcpPackets,
 110                   std::map<uint8_t, int>* packet_counters);
 111
 112     void SetTemporalToggle(unsigned char layers);
 113     void EnableSSRCCheck();
 114     unsigned int ReceivedSSRC();
 115
 116     void EnableSequenceNumberCheck();
 117     unsigned short GetFirstSequenceNumber();
 118
 119     bool EmptyQueue() const;
 120
 121 protected:
 122     static bool ViEExternalTransportRun(void* object);
 123     bool ViEExternalTransportProcess();
 124 private:
 125     // TODO(mikhal): Break these out to classes.
 126     static int GaussianRandom(int mean_ms, int standard_deviation_ms);
 127     bool UniformLoss(int loss_rate);
 128     bool GilbertElliotLoss(int loss_rate, int burst_length);
 129     int64_t NowMs();
 130
 131     enum
 132     {
 133         KMaxPacketSize = 1650
 134     };
 135     enum
 136     {
 137         KMaxWaitTimeMs = 100
 138     };
 139     typedef struct
 140     {
 141         int8_t packetBuffer[KMaxPacketSize];
 142         int32_t length;
 143         int32_t channel;
 144         int64_t receiveTime;
 145     } VideoPacket;
 146
 147     int sender_channel_;
 148     SsrcChannelMap* receive_channels_;
 149     webrtc::ViENetwork& _vieNetwork;
 150     webrtc::ThreadWrapper& _thread;
 151     webrtc::EventWrapper& _event;
 152     webrtc::CriticalSectionWrapper& _crit;
 153     webrtc::CriticalSectionWrapper& _statCrit;
 154
 155     NetworkParameters network_parameters_;
 156     int32_t _rtpCount;
 157     int32_t _rtcpCount;
 158     int32_t _dropCount;
 159     // |packet_counters| is a map which counts the number of packets sent per
 160     // payload type.
 161     std::map<uint8_t, int> packet_counters_;
 162
 163     std::list<VideoPacket*> _rtpPackets;
 164     std::list<VideoPacket*> _rtcpPackets;
 165
 166     SendFrameCallback* _send_frame_callback;
 167     ReceiveFrameCallback* _receive_frame_callback;
 168
 169     unsigned char _temporalLayers;
 170     unsigned short _seqNum;
 171     unsigned short _sendPID;
 172     unsigned char _receivedPID;
 173     bool _switchLayer;
 174     unsigned char _currentRelayLayer;
 175     unsigned int _lastTimeMs;
 176
 177     bool _checkSSRC;
 178     uint32_t _lastSSRC;
 179     bool _filterSSRC;
 180     uint32_t _SSRC;
 181     bool _checkSequenceNumber;
 182     uint16_t _firstSequenceNumber;
 183
 184     // Keep track of the first RTP timestamp so we don't do packet loss on
 185     // the first frame.
 186     uint32_t _firstRTPTimestamp;
 187     // Track RTP timestamps so we invoke callbacks properly (if registered).
 188     uint32_t _lastSendRTPTimestamp;
 189     uint32_t _lastReceiveRTPTimestamp;
 190     int64_t last_receive_time_;
 191     bool previous_drop_;
 192 };
 193
 194 #endif  // WEBRTC_VIDEO_ENGINE_TEST_AUTOTEST_INTERFACE_TB_EXTERNAL_TRANSPORT_H_