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 GetBandwidthUsage(uint32_t* total_bitrate_sent,
 206                          uint32_t* video_bitrate_sent,
 207                          uint32_t* fec_bitrate_sent,
 208                          uint32_t* nackBitrateSent) const;
 209   bool GetSendSideDelay(int* avg_send_delay, int* max_send_delay) const;
 210   void GetEstimatedReceiveBandwidth(uint32_t* estimated_bandwidth) const;
 211   void GetReceiveBandwidthEstimatorStats(
 212       ReceiveBandwidthEstimatorStats* output) const;
 213
 214   // Called on any new send bitrate estimate.
 215   void RegisterSendBitrateObserver(BitrateStatisticsObserver* observer);
 216
 217   int32_t StartRTPDump(const char file_nameUTF8[1024],
 218                        RTPDirections direction);
 219   int32_t StopRTPDump(RTPDirections direction);
 220
 221   // Implements RtcpFeedback.
 222   // TODO(pwestin) Depricate this functionality.
 223   virtual void OnApplicationDataReceived(const int32_t id,
 224                                          const uint8_t sub_type,
 225                                          const uint32_t name,
 226                                          const uint16_t length,
 227                                          const uint8_t* data);
 228   // Implements RtpFeedback.
 229   virtual int32_t OnInitializeDecoder(
 230       const int32_t id,
 231       const int8_t payload_type,
 232       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
 233       const int frequency,
 234       const uint8_t channels,
 235       const uint32_t rate);
 236   virtual void OnIncomingSSRCChanged(const int32_t id,
 237                                      const uint32_t ssrc);
 238   virtual void OnIncomingCSRCChanged(const int32_t id,
 239                                      const uint32_t CSRC,
 240                                      const bool added);
 241   virtual void ResetStatistics(uint32_t);
 242
 243   int32_t SetLocalReceiver(const uint16_t rtp_port,
 244                            const uint16_t rtcp_port,
 245                            const char* ip_address);
 246   int32_t GetLocalReceiver(uint16_t* rtp_port,
 247                            uint16_t* rtcp_port,
 248                            char* ip_address) const;
 249   int32_t SetSendDestination(const char* ip_address,
 250                              const uint16_t rtp_port,
 251                              const uint16_t rtcp_port,
 252                              const uint16_t source_rtp_port,
 253                              const uint16_t source_rtcp_port);
 254   int32_t GetSendDestination(char* ip_address,
 255                              uint16_t* rtp_port,
 256                              uint16_t* rtcp_port,
 257                              uint16_t* source_rtp_port,
 258                              uint16_t* source_rtcp_port) const;
 259   int32_t GetSourceInfo(uint16_t* rtp_port,
 260                         uint16_t* rtcp_port,
 261                         char* ip_address,
 262                         uint32_t ip_address_length);
 263
 264   int32_t SetRemoteSSRCType(const StreamType usage, const uint32_t SSRC);
 265
 266   int32_t StartSend();
 267   int32_t StopSend();
 268   bool Sending();
 269   int32_t StartReceive();
 270   int32_t StopReceive();
 271
 272   int32_t RegisterSendTransport(Transport* transport);
 273   int32_t DeregisterSendTransport();
 274
 275   // Incoming packet from external transport.
 276   int32_t ReceivedRTPPacket(const void* rtp_packet,
 277                             const int32_t rtp_packet_length,
 278                             const PacketTime& packet_time);
 279
 280   // Incoming packet from external transport.
 281   int32_t ReceivedRTCPPacket(const void* rtcp_packet,
 282                              const int32_t rtcp_packet_length);
 283
 284   // Sets the maximum transfer unit size for the network link, i.e. including
 285   // IP, UDP and RTP headers.
 286   int32_t SetMTU(uint16_t mtu);
 287
 288   // Returns maximum allowed payload size, i.e. the maximum allowed size of
 289   // encoded data in each packet.
 290   uint16_t MaxDataPayloadLength() const;
 291   int32_t SetMaxPacketBurstSize(uint16_t max_number_of_packets);
 292   int32_t SetPacketBurstSpreadState(bool enable, const uint16_t frame_periodMS);
 293
 294   int32_t EnableColorEnhancement(bool enable);
 295
 296   // Gets the modules used by the channel.
 297   RtpRtcp* rtp_rtcp();
 298
 299   CallStatsObserver* GetStatsObserver();
 300
 301   // Implements VCMReceiveCallback.
 302   virtual int32_t FrameToRender(I420VideoFrame& video_frame);  // NOLINT
 303
 304   // Implements VCMReceiveCallback.
 305   virtual int32_t ReceivedDecodedReferenceFrame(
 306       const uint64_t picture_id);
 307
 308   // Implements VCMReceiveCallback.
 309   virtual void IncomingCodecChanged(const VideoCodec& codec);
 310
 311   // Implements VCMReceiveStatisticsCallback.
 312   virtual int32_t OnReceiveStatisticsUpdate(const uint32_t bit_rate,
 313                                     const uint32_t frame_rate);
 314
 315   // Implements VCMDecoderTimingCallback.
 316   virtual void OnDecoderTiming(int decode_ms,
 317                                int max_decode_ms,
 318                                int current_delay_ms,
 319                                int target_delay_ms,
 320                                int jitter_buffer_ms,
 321                                int min_playout_delay_ms,
 322                                int render_delay_ms);
 323
 324   // Implements VideoFrameTypeCallback.
 325   virtual int32_t RequestKeyFrame();
 326
 327   // Implements VideoFrameTypeCallback.
 328   virtual int32_t SliceLossIndicationRequest(
 329       const uint64_t picture_id);
 330
 331   // Implements VideoPacketRequestCallback.
 332   virtual int32_t ResendPackets(const uint16_t* sequence_numbers,
 333                                 uint16_t length);
 334
 335   int32_t SetVoiceChannel(int32_t ve_channel_id,
 336                           VoEVideoSync* ve_sync_interface);
 337   int32_t VoiceChannel();
 338
 339   // Implements ViEFrameProviderBase.
 340   virtual int FrameCallbackChanged() {return -1;}
 341
 342   int32_t RegisterEffectFilter(ViEEffectFilter* effect_filter);
 343
 344   // New-style callbacks, used by VideoReceiveStream.
 345   void RegisterPreRenderCallback(I420FrameCallback* pre_render_callback);
 346   void RegisterPreDecodeImageCallback(
 347       EncodedImageCallback* pre_decode_callback);
 348
 349   void RegisterSendFrameCountObserver(FrameCountObserver* observer);
 350
 351  protected:
 352   static bool ChannelDecodeThreadFunction(void* obj);
 353   bool ChannelDecodeProcess();
 354
 355   void OnRttUpdate(uint32_t rtt);
 356
 357  private:
 358   // Assumed to be protected.
 359   int32_t StartDecodeThread();
 360   int32_t StopDecodeThread();
 361
 362   int32_t ProcessNACKRequest(const bool enable);
 363   int32_t ProcessFECRequest(const bool enable,
 364                             const unsigned char payload_typeRED,
 365                             const unsigned char payload_typeFEC);
 366   // Compute NACK list parameters for the buffering mode.
 367   int GetRequiredNackListSize(int target_delay_ms);
 368
 369   int32_t channel_id_;
 370   int32_t engine_id_;
 371   uint32_t number_of_cores_;
 372   uint8_t num_socket_threads_;
 373
 374   // Used for all registered callbacks except rendering.
 375   scoped_ptr<CriticalSectionWrapper> callback_cs_;
 376   scoped_ptr<CriticalSectionWrapper> rtp_rtcp_cs_;
 377
 378   RtpRtcp* default_rtp_rtcp_;
 379
 380   // Owned modules/classes.
 381   scoped_ptr<RtpRtcp> rtp_rtcp_;
 382   std::list<RtpRtcp*> simulcast_rtp_rtcp_;
 383   std::list<RtpRtcp*> removed_rtp_rtcp_;
 384   VideoCodingModule& vcm_;
 385   ViEReceiver vie_receiver_;
 386   ViESender vie_sender_;
 387   ViESyncModule vie_sync_;
 388
 389   // Helper to report call statistics.
 390   scoped_ptr<ChannelStatsObserver> stats_observer_;
 391
 392   // Not owned.
 393   ProcessThread& module_process_thread_;
 394   ViEDecoderObserver* codec_observer_;
 395   bool do_key_frame_callbackRequest_;
 396   ViERTPObserver* rtp_observer_;
 397   ViERTCPObserver* rtcp_observer_;
 398   RtcpIntraFrameObserver* intra_frame_observer_;
 399   RtcpRttStats* rtt_stats_;
 400   PacedSender* paced_sender_;
 401
 402   scoped_ptr<RtcpBandwidthObserver> bandwidth_observer_;
 403   int send_timestamp_extension_id_;
 404   int absolute_send_time_extension_id_;
 405
 406   Transport* external_transport_;
 407
 408   bool decoder_reset_;
 409   // Current receive codec used for codec change callback.
 410   VideoCodec receive_codec_;
 411   bool wait_for_key_frame_;
 412   ThreadWrapper* decode_thread_;
 413
 414   ViEEffectFilter* effect_filter_;
 415   bool color_enhancement_;
 416
 417   // User set MTU, -1 if not set.
 418   uint16_t mtu_;
 419   const bool sender_;
 420
 421   int nack_history_size_sender_;
 422   int max_nack_reordering_threshold_;
 423   I420FrameCallback* pre_render_callback_;
 424   const Config& config_;
 425 };
 426
 427 }  // namespace webrtc
 428
 429 #endif  // WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_