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#ifndef WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_
12#define WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_
13
14#include <list>
15
16#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
17#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
18#include "webrtc/modules/video_coding/main/interface/video_coding_defines.h"
19#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
20#include "webrtc/system_wrappers/interface/scoped_ptr.h"
21#include "webrtc/system_wrappers/interface/tick_util.h"
22#include "webrtc/typedefs.h"
23#include "webrtc/video_engine/include/vie_network.h"
24#include "webrtc/video_engine/include/vie_rtp_rtcp.h"
25#include "webrtc/video_engine/vie_defines.h"
26#include "webrtc/video_engine/vie_frame_provider_base.h"
27#include "webrtc/video_engine/vie_receiver.h"
28#include "webrtc/video_engine/vie_sender.h"
29#include "webrtc/video_engine/vie_sync_module.h"
30
31namespace webrtc {
32
33class CallStatsObserver;
34class ChannelStatsObserver;
35class Config;
36class CriticalSectionWrapper;
37class EncodedImageCallback;
38class I420FrameCallback;
39class PacedSender;
40class ProcessThread;
41class RtcpRttStats;
42class RtpRtcp;
43class ThreadWrapper;
44class ViEDecoderObserver;
45class ViEEffectFilter;
46class ViERTCPObserver;
47class ViERTPObserver;
48class VideoCodingModule;
49class VideoDecoder;
50class VideoRenderCallback;
51class VoEVideoSync;
52
53class ViEChannel
54    : public VCMFrameTypeCallback,
55      public VCMReceiveCallback,
56      public VCMReceiveStatisticsCallback,
57      public VCMDecoderTimingCallback,
58      public VCMPacketRequestCallback,
59      public RtcpFeedback,
60      public RtpFeedback,
61      public ViEFrameProviderBase {
62 public:
63  friend class ChannelStatsObserver;
64
65  ViEChannel(int32_t channel_id,
66             int32_t engine_id,
67             uint32_t number_of_cores,
68             const Config& config,
69             ProcessThread& module_process_thread,
70             RtcpIntraFrameObserver* intra_frame_observer,
71             RtcpBandwidthObserver* bandwidth_observer,
72             RemoteBitrateEstimator* remote_bitrate_estimator,
73             RtcpRttStats* rtt_stats,
74             PacedSender* paced_sender,
75             RtpRtcp* default_rtp_rtcp,
76             bool sender);
77  ~ViEChannel();
78
79  int32_t Init();
80
81  // Sets the encoder to use for the channel. |new_stream| indicates the encoder
82  // type has changed and we should start a new RTP stream.
83  int32_t SetSendCodec(const VideoCodec& video_codec, bool new_stream = true);
84  int32_t SetReceiveCodec(const VideoCodec& video_codec);
85  int32_t GetReceiveCodec(VideoCodec* video_codec);
86  int32_t RegisterCodecObserver(ViEDecoderObserver* observer);
87  // Registers an external decoder. |buffered_rendering| means that the decoder
88  // will render frames after decoding according to the render timestamp
89  // provided by the video coding module. |render_delay| indicates the time
90  // needed to decode and render a frame.
91  int32_t RegisterExternalDecoder(const uint8_t pl_type,
92                                  VideoDecoder* decoder,
93                                  bool buffered_rendering,
94                                  int32_t render_delay);
95  int32_t DeRegisterExternalDecoder(const uint8_t pl_type);
96  int32_t ReceiveCodecStatistics(uint32_t* num_key_frames,
97                                 uint32_t* num_delta_frames);
98  uint32_t DiscardedPackets() const;
99
100  // Returns the estimated delay in milliseconds.
101  int ReceiveDelay() const;
102
103  // Only affects calls to SetReceiveCodec done after this call.
104  int32_t WaitForKeyFrame(bool wait);
105
106  // If enabled, a key frame request will be sent as soon as there are lost
107  // packets. If |only_key_frames| are set, requests are only sent for loss in
108  // key frames.
109  int32_t SetSignalPacketLossStatus(bool enable, bool only_key_frames);
110
111  int32_t SetRTCPMode(const RTCPMethod rtcp_mode);
112  int32_t GetRTCPMode(RTCPMethod* rtcp_mode);
113  int32_t SetNACKStatus(const bool enable);
114  int32_t SetFECStatus(const bool enable,
115                       const unsigned char payload_typeRED,
116                       const unsigned char payload_typeFEC);
117  int32_t SetHybridNACKFECStatus(const bool enable,
118                                 const unsigned char payload_typeRED,
119                                 const unsigned char payload_typeFEC);
120  int SetSenderBufferingMode(int target_delay_ms);
121  int SetReceiverBufferingMode(int target_delay_ms);
122  int32_t SetKeyFrameRequestMethod(const KeyFrameRequestMethod method);
123  bool EnableRemb(bool enable);
124  int SetSendTimestampOffsetStatus(bool enable, int id);
125  int SetReceiveTimestampOffsetStatus(bool enable, int id);
126  int SetSendAbsoluteSendTimeStatus(bool enable, int id);
127  int SetReceiveAbsoluteSendTimeStatus(bool enable, int id);
128  bool GetReceiveAbsoluteSendTimeStatus() const;
129  void SetRtcpXrRrtrStatus(bool enable);
130  void SetTransmissionSmoothingStatus(bool enable);
131  int32_t EnableTMMBR(const bool enable);
132  int32_t EnableKeyFrameRequestCallback(const bool enable);
133
134  // Sets SSRC for outgoing stream.
135  int32_t SetSSRC(const uint32_t SSRC,
136                  const StreamType usage,
137                  const unsigned char simulcast_idx);
138
139  // Gets SSRC for outgoing stream number |idx|.
140  int32_t GetLocalSSRC(uint8_t idx, unsigned int* ssrc);
141
142  // Gets SSRC for the incoming stream.
143  int32_t GetRemoteSSRC(uint32_t* ssrc);
144
145  // Gets the CSRC for the incoming stream.
146  int32_t GetRemoteCSRC(uint32_t CSRCs[kRtpCsrcSize]);
147
148  int SetRtxSendPayloadType(int payload_type);
149  // Only has an effect once RTX is enabled.
150  void SetPadWithRedundantPayloads(bool enable);
151  void SetRtxReceivePayloadType(int payload_type);
152
153  // Sets the starting sequence number, must be called before StartSend.
154  int32_t SetStartSequenceNumber(uint16_t sequence_number);
155
156  void SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state);
157  RtpState GetRtpStateForSsrc(uint32_t ssrc);
158
159  // Sets the CName for the outgoing stream on the channel.
160  int32_t SetRTCPCName(const char rtcp_cname[]);
161
162  // Gets the CName of the incoming stream.
163  int32_t GetRemoteRTCPCName(char rtcp_cname[]);
164  int32_t RegisterRtpObserver(ViERTPObserver* observer);
165  int32_t RegisterRtcpObserver(ViERTCPObserver* observer);
166  int32_t SendApplicationDefinedRTCPPacket(
167      const uint8_t sub_type,
168      uint32_t name,
169      const uint8_t* data,
170      uint16_t data_length_in_bytes);
171
172  // Returns statistics reported by the remote client in an RTCP packet.
173  int32_t GetSendRtcpStatistics(uint16_t* fraction_lost,
174                                uint32_t* cumulative_lost,
175                                uint32_t* extended_max,
176                                uint32_t* jitter_samples,
177                                int32_t* rtt_ms);
178
179  // Called on receipt of RTCP report block from remote side.
180  void RegisterSendChannelRtcpStatisticsCallback(
181      RtcpStatisticsCallback* callback);
182
183  // Returns our localy created statistics of the received RTP stream.
184  int32_t GetReceivedRtcpStatistics(uint16_t* fraction_lost,
185                                    uint32_t* cumulative_lost,
186                                    uint32_t* extended_max,
187                                    uint32_t* jitter_samples,
188                                    int32_t* rtt_ms);
189
190  // Called on generation of RTCP stats
191  void RegisterReceiveChannelRtcpStatisticsCallback(
192      RtcpStatisticsCallback* callback);
193
194  // Gets sent/received packets statistics.
195  int32_t GetRtpStatistics(uint32_t* bytes_sent,
196                           uint32_t* packets_sent,
197                           uint32_t* bytes_received,
198                           uint32_t* packets_received) const;
199
200  // Called on update of RTP statistics.
201  void RegisterSendChannelRtpStatisticsCallback(
202      StreamDataCountersCallback* callback);
203
204  // Called on update of RTP statistics.
205  void RegisterReceiveChannelRtpStatisticsCallback(
206      StreamDataCountersCallback* callback);
207
208  void GetRtcpPacketTypeCounters(RtcpPacketTypeCounter* packets_sent,
209                                 RtcpPacketTypeCounter* packets_received) const;
210
211  void GetBandwidthUsage(uint32_t* total_bitrate_sent,
212                         uint32_t* video_bitrate_sent,
213                         uint32_t* fec_bitrate_sent,
214                         uint32_t* nackBitrateSent) const;
215  // TODO(holmer): Deprecated. We should use the SendSideDelayObserver instead
216  // to avoid deadlocks.
217  bool GetSendSideDelay(int* avg_send_delay, int* max_send_delay) const;
218  void RegisterSendSideDelayObserver(SendSideDelayObserver* observer);
219  void GetReceiveBandwidthEstimatorStats(
220      ReceiveBandwidthEstimatorStats* output) const;
221
222  // Called on any new send bitrate estimate.
223  void RegisterSendBitrateObserver(BitrateStatisticsObserver* observer);
224
225  int32_t StartRTPDump(const char file_nameUTF8[1024],
226                       RTPDirections direction);
227  int32_t StopRTPDump(RTPDirections direction);
228
229  // Implements RtcpFeedback.
230  // TODO(pwestin) Depricate this functionality.
231  virtual void OnApplicationDataReceived(const int32_t id,
232                                         const uint8_t sub_type,
233                                         const uint32_t name,
234                                         const uint16_t length,
235                                         const uint8_t* data);
236  // Implements RtpFeedback.
237  virtual int32_t OnInitializeDecoder(
238      const int32_t id,
239      const int8_t payload_type,
240      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
241      const int frequency,
242      const uint8_t channels,
243      const uint32_t rate);
244  virtual void OnIncomingSSRCChanged(const int32_t id,
245                                     const uint32_t ssrc);
246  virtual void OnIncomingCSRCChanged(const int32_t id,
247                                     const uint32_t CSRC,
248                                     const bool added);
249  virtual void ResetStatistics(uint32_t);
250
251  int32_t SetLocalReceiver(const uint16_t rtp_port,
252                           const uint16_t rtcp_port,
253                           const char* ip_address);
254  int32_t GetLocalReceiver(uint16_t* rtp_port,
255                           uint16_t* rtcp_port,
256                           char* ip_address) const;
257  int32_t SetSendDestination(const char* ip_address,
258                             const uint16_t rtp_port,
259                             const uint16_t rtcp_port,
260                             const uint16_t source_rtp_port,
261                             const uint16_t source_rtcp_port);
262  int32_t GetSendDestination(char* ip_address,
263                             uint16_t* rtp_port,
264                             uint16_t* rtcp_port,
265                             uint16_t* source_rtp_port,
266                             uint16_t* source_rtcp_port) const;
267  int32_t GetSourceInfo(uint16_t* rtp_port,
268                        uint16_t* rtcp_port,
269                        char* ip_address,
270                        uint32_t ip_address_length);
271
272  int32_t SetRemoteSSRCType(const StreamType usage, const uint32_t SSRC);
273
274  int32_t StartSend();
275  int32_t StopSend();
276  bool Sending();
277  int32_t StartReceive();
278  int32_t StopReceive();
279
280  int32_t RegisterSendTransport(Transport* transport);
281  int32_t DeregisterSendTransport();
282
283  // Incoming packet from external transport.
284  int32_t ReceivedRTPPacket(const void* rtp_packet,
285                            const int32_t rtp_packet_length,
286                            const PacketTime& packet_time);
287
288  // Incoming packet from external transport.
289  int32_t ReceivedRTCPPacket(const void* rtcp_packet,
290                             const int32_t rtcp_packet_length);
291
292  // Sets the maximum transfer unit size for the network link, i.e. including
293  // IP, UDP and RTP headers.
294  int32_t SetMTU(uint16_t mtu);
295
296  // Returns maximum allowed payload size, i.e. the maximum allowed size of
297  // encoded data in each packet.
298  uint16_t MaxDataPayloadLength() const;
299  int32_t SetMaxPacketBurstSize(uint16_t max_number_of_packets);
300  int32_t SetPacketBurstSpreadState(bool enable, const uint16_t frame_periodMS);
301
302  int32_t EnableColorEnhancement(bool enable);
303
304  // Gets the modules used by the channel.
305  RtpRtcp* rtp_rtcp();
306
307  CallStatsObserver* GetStatsObserver();
308
309  // Implements VCMReceiveCallback.
310  virtual int32_t FrameToRender(I420VideoFrame& video_frame);  // NOLINT
311
312  // Implements VCMReceiveCallback.
313  virtual int32_t ReceivedDecodedReferenceFrame(
314      const uint64_t picture_id);
315
316  // Implements VCMReceiveCallback.
317  virtual void IncomingCodecChanged(const VideoCodec& codec);
318
319  // Implements VCMReceiveStatisticsCallback.
320  virtual int32_t OnReceiveStatisticsUpdate(const uint32_t bit_rate,
321                                    const uint32_t frame_rate);
322
323  // Implements VCMDecoderTimingCallback.
324  virtual void OnDecoderTiming(int decode_ms,
325                               int max_decode_ms,
326                               int current_delay_ms,
327                               int target_delay_ms,
328                               int jitter_buffer_ms,
329                               int min_playout_delay_ms,
330                               int render_delay_ms);
331
332  // Implements VideoFrameTypeCallback.
333  virtual int32_t RequestKeyFrame();
334
335  // Implements VideoFrameTypeCallback.
336  virtual int32_t SliceLossIndicationRequest(
337      const uint64_t picture_id);
338
339  // Implements VideoPacketRequestCallback.
340  virtual int32_t ResendPackets(const uint16_t* sequence_numbers,
341                                uint16_t length);
342
343  int32_t SetVoiceChannel(int32_t ve_channel_id,
344                          VoEVideoSync* ve_sync_interface);
345  int32_t VoiceChannel();
346
347  // Implements ViEFrameProviderBase.
348  virtual int FrameCallbackChanged() {return -1;}
349
350  int32_t RegisterEffectFilter(ViEEffectFilter* effect_filter);
351
352  // New-style callbacks, used by VideoReceiveStream.
353  void RegisterPreRenderCallback(I420FrameCallback* pre_render_callback);
354  void RegisterPreDecodeImageCallback(
355      EncodedImageCallback* pre_decode_callback);
356
357  void RegisterSendFrameCountObserver(FrameCountObserver* observer);
358
359  void ReceivedBWEPacket(int64_t arrival_time_ms, int payload_size,
360                         const RTPHeader& header);
361
362 protected:
363  static bool ChannelDecodeThreadFunction(void* obj);
364  bool ChannelDecodeProcess();
365
366  void OnRttUpdate(uint32_t rtt);
367
368 private:
369  void ReserveRtpRtcpModules(size_t total_modules)
370      EXCLUSIVE_LOCKS_REQUIRED(rtp_rtcp_cs_);
371  RtpRtcp* GetRtpRtcpModule(size_t simulcast_idx) const
372      EXCLUSIVE_LOCKS_REQUIRED(rtp_rtcp_cs_);
373  RtpRtcp* CreateRtpRtcpModule();
374  // Assumed to be protected.
375  int32_t StartDecodeThread();
376  int32_t StopDecodeThread();
377
378  int32_t ProcessNACKRequest(const bool enable);
379  int32_t ProcessFECRequest(const bool enable,
380                            const unsigned char payload_typeRED,
381                            const unsigned char payload_typeFEC);
382  // Compute NACK list parameters for the buffering mode.
383  int GetRequiredNackListSize(int target_delay_ms);
384  void SetRtxSendStatus(bool enable);
385
386  // ViEChannel exposes methods that allow to modify observers and callbacks
387  // to be modified. Such an API-style is cumbersome to implement and maintain
388  // at all the levels when comparing to only setting them at construction. As
389  // so this class instantiates its children with a wrapper that can be modified
390  // at a later time.
391  template <class T>
392  class RegisterableCallback : public T {
393   public:
394    RegisterableCallback()
395        : critsect_(CriticalSectionWrapper::CreateCriticalSection()),
396          callback_(NULL) {}
397
398    void Set(T* callback) {
399      CriticalSectionScoped cs(critsect_.get());
400      callback_ = callback;
401    }
402
403   protected:
404    // Note: this should be implemented with a RW-lock to allow simultaneous
405    // calls into the callback. However that doesn't seem to be needed for the
406    // current type of callbacks covered by this class.
407    scoped_ptr<CriticalSectionWrapper> critsect_;
408    T* callback_ GUARDED_BY(critsect_);
409
410   private:
411    DISALLOW_COPY_AND_ASSIGN(RegisterableCallback);
412  };
413
414  class RegisterableBitrateStatisticsObserver:
415    public RegisterableCallback<BitrateStatisticsObserver> {
416    virtual void Notify(const BitrateStatistics& stats, uint32_t ssrc) {
417      CriticalSectionScoped cs(critsect_.get());
418      if (callback_)
419        callback_->Notify(stats, ssrc);
420    }
421  }
422  send_bitrate_observer_;
423
424  class RegisterableFrameCountObserver
425      : public RegisterableCallback<FrameCountObserver> {
426    virtual void FrameCountUpdated(FrameType frame_type,
427                                   uint32_t frame_count,
428                                   const unsigned int ssrc) {
429      CriticalSectionScoped cs(critsect_.get());
430      if (callback_)
431        callback_->FrameCountUpdated(frame_type, frame_count, ssrc);
432    }
433  } send_frame_count_observer_;
434
435  class RegisterableSendSideDelayObserver :
436      public RegisterableCallback<SendSideDelayObserver> {
437    virtual void SendSideDelayUpdated(int avg_delay_ms,
438                                      int max_delay_ms,
439                                      uint32_t ssrc) OVERRIDE {
440      CriticalSectionScoped cs(critsect_.get());
441      if (callback_)
442        callback_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, ssrc);
443    }
444  } send_side_delay_observer_;
445
446  int32_t channel_id_;
447  int32_t engine_id_;
448  uint32_t number_of_cores_;
449  uint8_t num_socket_threads_;
450
451  // Used for all registered callbacks except rendering.
452  scoped_ptr<CriticalSectionWrapper> callback_cs_;
453  scoped_ptr<CriticalSectionWrapper> rtp_rtcp_cs_;
454
455  RtpRtcp* default_rtp_rtcp_;
456
457  // Owned modules/classes.
458  scoped_ptr<RtpRtcp> rtp_rtcp_;
459  std::list<RtpRtcp*> simulcast_rtp_rtcp_;
460  std::list<RtpRtcp*> removed_rtp_rtcp_;
461  VideoCodingModule* const vcm_;
462  ViEReceiver vie_receiver_;
463  ViESender vie_sender_;
464  ViESyncModule vie_sync_;
465
466  // Helper to report call statistics.
467  scoped_ptr<ChannelStatsObserver> stats_observer_;
468
469  // Not owned.
470  ProcessThread& module_process_thread_;
471  ViEDecoderObserver* codec_observer_;
472  bool do_key_frame_callbackRequest_;
473  ViERTPObserver* rtp_observer_;
474  ViERTCPObserver* rtcp_observer_;
475  RtcpIntraFrameObserver* intra_frame_observer_;
476  RtcpRttStats* rtt_stats_;
477  PacedSender* paced_sender_;
478  bool pad_with_redundant_payloads_;
479
480  scoped_ptr<RtcpBandwidthObserver> bandwidth_observer_;
481  int send_timestamp_extension_id_;
482  int absolute_send_time_extension_id_;
483
484  Transport* external_transport_;
485
486  bool decoder_reset_;
487  // Current receive codec used for codec change callback.
488  VideoCodec receive_codec_;
489  bool wait_for_key_frame_;
490  ThreadWrapper* decode_thread_;
491
492  ViEEffectFilter* effect_filter_;
493  bool color_enhancement_;
494
495  // User set MTU, -1 if not set.
496  uint16_t mtu_;
497  const bool sender_;
498
499  int nack_history_size_sender_;
500  int max_nack_reordering_threshold_;
501  I420FrameCallback* pre_render_callback_;
502
503  std::map<uint32_t, RTCPReportBlock> prev_report_blocks_;
504};
505
506}  // namespace webrtc
507
508#endif  // WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_
509