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