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