Reland of Merge webrtc/video_engine/ into webrtc/video/

webrtc/video_engine/vie_channel.h

Index: webrtc/video_engine/vie_channel.h
diff --git a/webrtc/video_engine/vie_channel.h b/webrtc/video_engine/vie_channel.h
deleted file mode 100644
index 00c953201b529c67f8727b6a21a1fb3cb6d59c22..0000000000000000000000000000000000000000
--- a/webrtc/video_engine/vie_channel.h
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
- *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_
-#define WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_
-
-#include <list>
-#include <map>
-#include <vector>
-
-#include "webrtc/base/platform_thread.h"
-#include "webrtc/base/scoped_ptr.h"
-#include "webrtc/base/scoped_ref_ptr.h"
-#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "webrtc/modules/video_coding/include/video_coding_defines.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
-#include "webrtc/typedefs.h"
-#include "webrtc/video_engine/vie_receiver.h"
-#include "webrtc/video_engine/vie_sync_module.h"
-
-namespace webrtc {
-
-class CallStatsObserver;
-class ChannelStatsObserver;
-class Config;
-class CriticalSectionWrapper;
-class EncodedImageCallback;
-class I420FrameCallback;
-class IncomingVideoStream;
-class PacedSender;
-class PacketRouter;
-class PayloadRouter;
-class ProcessThread;
-class ReceiveStatisticsProxy;
-class ReportBlockStats;
-class RtcpRttStats;
-class ViEChannelProtectionCallback;
-class ViERTPObserver;
-class VideoCodingModule;
-class VideoDecoder;
-class VideoRenderCallback;
-class VoEVideoSync;
-
-enum StreamType {
-  kViEStreamTypeNormal = 0,  // Normal media stream
-  kViEStreamTypeRtx = 1      // Retransmission media stream
-};
-
-class ViEChannel : public VCMFrameTypeCallback,
-                   public VCMReceiveCallback,
-                   public VCMReceiveStatisticsCallback,
-                   public VCMDecoderTimingCallback,
-                   public VCMPacketRequestCallback,
-                   public RtpFeedback {
- public:
-  friend class ChannelStatsObserver;
-  friend class ViEChannelProtectionCallback;
-
-  ViEChannel(uint32_t number_of_cores,
-             Transport* transport,
-             ProcessThread* module_process_thread,
-             RtcpIntraFrameObserver* intra_frame_observer,
-             RtcpBandwidthObserver* bandwidth_observer,
-             TransportFeedbackObserver* transport_feedback_observer,
-             RemoteBitrateEstimator* remote_bitrate_estimator,
-             RtcpRttStats* rtt_stats,
-             PacedSender* paced_sender,
-             PacketRouter* packet_router,
-             size_t max_rtp_streams,
-             bool sender);
-  ~ViEChannel();
-
-  int32_t Init();
-
-  // Sets the encoder to use for the channel. |new_stream| indicates the encoder
-  // type has changed and we should start a new RTP stream.
-  int32_t SetSendCodec(const VideoCodec& video_codec, bool new_stream = true);
-  int32_t SetReceiveCodec(const VideoCodec& video_codec);
-  // Registers an external decoder. |buffered_rendering| means that the decoder
-  // will render frames after decoding according to the render timestamp
-  // provided by the video coding module. |render_delay| indicates the time
-  // needed to decode and render a frame.
-  int32_t RegisterExternalDecoder(const uint8_t pl_type,
-                                  VideoDecoder* decoder,
-                                  bool buffered_rendering,
-                                  int32_t render_delay);
-  int32_t ReceiveCodecStatistics(uint32_t* num_key_frames,
-                                 uint32_t* num_delta_frames);
-  uint32_t DiscardedPackets() const;
-
-  // Returns the estimated delay in milliseconds.
-  int ReceiveDelay() const;
-
-  void SetRTCPMode(const RtcpMode rtcp_mode);
-  void SetProtectionMode(bool enable_nack,
-                         bool enable_fec,
-                         int payload_type_red,
-                         int payload_type_fec);
-  bool IsSendingFecEnabled();
-  int SetSenderBufferingMode(int target_delay_ms);
-  int SetSendTimestampOffsetStatus(bool enable, int id);
-  int SetReceiveTimestampOffsetStatus(bool enable, int id);
-  int SetSendAbsoluteSendTimeStatus(bool enable, int id);
-  int SetReceiveAbsoluteSendTimeStatus(bool enable, int id);
-  int SetSendVideoRotationStatus(bool enable, int id);
-  int SetReceiveVideoRotationStatus(bool enable, int id);
-  int SetSendTransportSequenceNumber(bool enable, int id);
-  int SetReceiveTransportSequenceNumber(bool enable, int id);
-  void SetRtcpXrRrtrStatus(bool enable);
-  void EnableTMMBR(bool enable);
-
-  // Sets SSRC for outgoing stream.
-  int32_t SetSSRC(const uint32_t SSRC,
-                  const StreamType usage,
-                  const unsigned char simulcast_idx);
-
-  // Gets SSRC for outgoing stream number |idx|.
-  int32_t GetLocalSSRC(uint8_t idx, unsigned int* ssrc);
-
-  // Gets SSRC for the incoming stream.
-  uint32_t GetRemoteSSRC();
-
-  int SetRtxSendPayloadType(int payload_type, int associated_payload_type);
-  void SetRtxReceivePayloadType(int payload_type, int associated_payload_type);
-  // If set to true, the RTX payload type mapping supplied in
-  // |SetRtxReceivePayloadType| will be used when restoring RTX packets. Without
-  // it, RTX packets will always be restored to the last non-RTX packet payload
-  // type received.
-  void SetUseRtxPayloadMappingOnRestore(bool val);
-
-  void SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state);
-  RtpState GetRtpStateForSsrc(uint32_t ssrc);
-
-  // Sets the CName for the outgoing stream on the channel.
-  int32_t SetRTCPCName(const char* rtcp_cname);
-
-  // Gets the CName of the incoming stream.
-  int32_t GetRemoteRTCPCName(char rtcp_cname[]);
-
-  // Returns statistics reported by the remote client in an RTCP packet.
-  // TODO(pbos): Remove this along with VideoSendStream::GetRtt().
-  int32_t GetSendRtcpStatistics(uint16_t* fraction_lost,
-                                uint32_t* cumulative_lost,
-                                uint32_t* extended_max,
-                                uint32_t* jitter_samples,
-                                int64_t* rtt_ms);
-
-  // Called on receipt of RTCP report block from remote side.
-  void RegisterSendChannelRtcpStatisticsCallback(
-      RtcpStatisticsCallback* callback);
-
-  // Called on generation of RTCP stats
-  void RegisterReceiveChannelRtcpStatisticsCallback(
-      RtcpStatisticsCallback* callback);
-
-  // Gets send statistics for the rtp and rtx stream.
-  void GetSendStreamDataCounters(StreamDataCounters* rtp_counters,
-                                 StreamDataCounters* rtx_counters) const;
-
-  // Gets received stream data counters.
-  void GetReceiveStreamDataCounters(StreamDataCounters* rtp_counters,
-                                    StreamDataCounters* rtx_counters) const;
-
-  // Called on update of RTP statistics.
-  void RegisterSendChannelRtpStatisticsCallback(
-      StreamDataCountersCallback* callback);
-
-  // Called on update of RTP statistics.
-  void RegisterReceiveChannelRtpStatisticsCallback(
-      StreamDataCountersCallback* callback);
-
-  void GetSendRtcpPacketTypeCounter(
-      RtcpPacketTypeCounter* packet_counter) const;
-
-  void GetReceiveRtcpPacketTypeCounter(
-      RtcpPacketTypeCounter* packet_counter) const;
-
-  void RegisterSendSideDelayObserver(SendSideDelayObserver* observer);
-
-  // Called on any new send bitrate estimate.
-  void RegisterSendBitrateObserver(BitrateStatisticsObserver* observer);
-
-  // Implements RtpFeedback.
-  int32_t OnInitializeDecoder(const int8_t payload_type,
-                              const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-                              const int frequency,
-                              const uint8_t channels,
-                              const uint32_t rate) override;
-  void OnIncomingSSRCChanged(const uint32_t ssrc) override;
-  void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) override;
-
-  int32_t SetRemoteSSRCType(const StreamType usage, const uint32_t SSRC);
-
-  int32_t StartSend();
-  int32_t StopSend();
-  bool Sending();
-  void StartReceive();
-  void StopReceive();
-
-  int32_t ReceivedRTPPacket(const void* rtp_packet,
-                            const size_t rtp_packet_length,
-                            const PacketTime& packet_time);
-  int32_t ReceivedRTCPPacket(const void* rtcp_packet,
-                             const size_t rtcp_packet_length);
-
-  // Sets the maximum transfer unit size for the network link, i.e. including
-  // IP, UDP and RTP headers.
-  int32_t SetMTU(uint16_t mtu);
-
-  // Gets the modules used by the channel.
-  RtpRtcp* rtp_rtcp();
-  rtc::scoped_refptr<PayloadRouter> send_payload_router();
-  VCMProtectionCallback* vcm_protection_callback();
-
-
-  CallStatsObserver* GetStatsObserver();
-
-  // Implements VCMReceiveCallback.
-  virtual int32_t FrameToRender(VideoFrame& video_frame);  // NOLINT
-
-  // Implements VCMReceiveCallback.
-  virtual int32_t ReceivedDecodedReferenceFrame(
-      const uint64_t picture_id);
-
-  // Implements VCMReceiveCallback.
-  void OnIncomingPayloadType(int payload_type) override;
-
-  // Implements VCMReceiveStatisticsCallback.
-  void OnReceiveRatesUpdated(uint32_t bit_rate, uint32_t frame_rate) override;
-  void OnDiscardedPacketsUpdated(int discarded_packets) override;
-  void OnFrameCountsUpdated(const FrameCounts& frame_counts) override;
-
-  // Implements VCMDecoderTimingCallback.
-  virtual void OnDecoderTiming(int decode_ms,
-                               int max_decode_ms,
-                               int current_delay_ms,
-                               int target_delay_ms,
-                               int jitter_buffer_ms,
-                               int min_playout_delay_ms,
-                               int render_delay_ms);
-
-  // Implements FrameTypeCallback.
-  virtual int32_t RequestKeyFrame();
-
-  // Implements FrameTypeCallback.
-  virtual int32_t SliceLossIndicationRequest(
-      const uint64_t picture_id);
-
-  // Implements VideoPacketRequestCallback.
-  int32_t ResendPackets(const uint16_t* sequence_numbers,
-                        uint16_t length) override;
-
-  int32_t SetVoiceChannel(int32_t ve_channel_id,
-                          VoEVideoSync* ve_sync_interface);
-  int32_t VoiceChannel();
-
-  // New-style callbacks, used by VideoReceiveStream.
-  void RegisterPreRenderCallback(I420FrameCallback* pre_render_callback);
-  void RegisterPreDecodeImageCallback(
-      EncodedImageCallback* pre_decode_callback);
-
-  void RegisterSendFrameCountObserver(FrameCountObserver* observer);
-  void RegisterRtcpPacketTypeCounterObserver(
-      RtcpPacketTypeCounterObserver* observer);
-  void RegisterReceiveStatisticsProxy(
-      ReceiveStatisticsProxy* receive_statistics_proxy);
-  void SetIncomingVideoStream(IncomingVideoStream* incoming_video_stream);
-
- protected:
-  static bool ChannelDecodeThreadFunction(void* obj);
-  bool ChannelDecodeProcess();
-
-  void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms);
-
-  int ProtectionRequest(const FecProtectionParams* delta_fec_params,
-                        const FecProtectionParams* key_fec_params,
-                        uint32_t* sent_video_rate_bps,
-                        uint32_t* sent_nack_rate_bps,
-                        uint32_t* sent_fec_rate_bps);
-
- private:
-  static std::vector<RtpRtcp*> CreateRtpRtcpModules(
-      bool receiver_only,
-      ReceiveStatistics* receive_statistics,
-      Transport* outgoing_transport,
-      RtcpIntraFrameObserver* intra_frame_callback,
-      RtcpBandwidthObserver* bandwidth_callback,
-      TransportFeedbackObserver* transport_feedback_callback,
-      RtcpRttStats* rtt_stats,
-      RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
-      RemoteBitrateEstimator* remote_bitrate_estimator,
-      RtpPacketSender* paced_sender,
-      TransportSequenceNumberAllocator* transport_sequence_number_allocator,
-      BitrateStatisticsObserver* send_bitrate_observer,
-      FrameCountObserver* send_frame_count_observer,
-      SendSideDelayObserver* send_side_delay_observer,
-      size_t num_modules);
-
-  // Assumed to be protected.
-  void StartDecodeThread();
-  void StopDecodeThread();
-
-  void ProcessNACKRequest(const bool enable);
-  // Compute NACK list parameters for the buffering mode.
-  int GetRequiredNackListSize(int target_delay_ms);
-  void SetRtxSendStatus(bool enable);
-
-  void UpdateHistograms();
-
-  // ViEChannel exposes methods that allow to modify observers and callbacks
-  // to be modified. Such an API-style is cumbersome to implement and maintain
-  // at all the levels when comparing to only setting them at construction. As
-  // so this class instantiates its children with a wrapper that can be modified
-  // at a later time.
-  template <class T>
-  class RegisterableCallback : public T {
-   public:
-    RegisterableCallback()
-        : critsect_(CriticalSectionWrapper::CreateCriticalSection()),
-          callback_(NULL) {}
-
-    void Set(T* callback) {
-      CriticalSectionScoped cs(critsect_.get());
-      callback_ = callback;
-    }
-
-   protected:
-    // Note: this should be implemented with a RW-lock to allow simultaneous
-    // calls into the callback. However that doesn't seem to be needed for the
-    // current type of callbacks covered by this class.
-    rtc::scoped_ptr<CriticalSectionWrapper> critsect_;
-    T* callback_ GUARDED_BY(critsect_);
-
-   private:
-    RTC_DISALLOW_COPY_AND_ASSIGN(RegisterableCallback);
-  };
-
-  class RegisterableBitrateStatisticsObserver:
-    public RegisterableCallback<BitrateStatisticsObserver> {
-    virtual void Notify(const BitrateStatistics& total_stats,
-                        const BitrateStatistics& retransmit_stats,
-                        uint32_t ssrc) {
-      CriticalSectionScoped cs(critsect_.get());
-      if (callback_)
-        callback_->Notify(total_stats, retransmit_stats, ssrc);
-    }
-  } send_bitrate_observer_;
-
-  class RegisterableFrameCountObserver
-      : public RegisterableCallback<FrameCountObserver> {
-   public:
-    virtual void FrameCountUpdated(const FrameCounts& frame_counts,
-                                   uint32_t ssrc) {
-      CriticalSectionScoped cs(critsect_.get());
-      if (callback_)
-        callback_->FrameCountUpdated(frame_counts, ssrc);
-    }
-
-   private:
-  } send_frame_count_observer_;
-
-  class RegisterableSendSideDelayObserver :
-      public RegisterableCallback<SendSideDelayObserver> {
-    void SendSideDelayUpdated(int avg_delay_ms,
-                              int max_delay_ms,
-                              uint32_t ssrc) override {
-      CriticalSectionScoped cs(critsect_.get());
-      if (callback_)
-        callback_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, ssrc);
-    }
-  } send_side_delay_observer_;
-
-  class RegisterableRtcpPacketTypeCounterObserver
-      : public RegisterableCallback<RtcpPacketTypeCounterObserver> {
-   public:
-    void RtcpPacketTypesCounterUpdated(
-        uint32_t ssrc,
-        const RtcpPacketTypeCounter& packet_counter) override {
-      CriticalSectionScoped cs(critsect_.get());
-      if (callback_)
-        callback_->RtcpPacketTypesCounterUpdated(ssrc, packet_counter);
-      counter_map_[ssrc] = packet_counter;
-    }
-
-    virtual std::map<uint32_t, RtcpPacketTypeCounter> GetPacketTypeCounterMap()
-        const {
-      CriticalSectionScoped cs(critsect_.get());
-      return counter_map_;
-    }
-
-   private:
-    std::map<uint32_t, RtcpPacketTypeCounter> counter_map_
-        GUARDED_BY(critsect_);
-  } rtcp_packet_type_counter_observer_;
-
-  const uint32_t number_of_cores_;
-  const bool sender_;
-
-  ProcessThread* const module_process_thread_;
-
-  // Used for all registered callbacks except rendering.
-  rtc::scoped_ptr<CriticalSectionWrapper> crit_;
-
-  // Owned modules/classes.
-  rtc::scoped_refptr<PayloadRouter> send_payload_router_;
-  rtc::scoped_ptr<ViEChannelProtectionCallback> vcm_protection_callback_;
-
-  VideoCodingModule* const vcm_;
-  ViEReceiver vie_receiver_;
-  ViESyncModule vie_sync_;
-
-  // Helper to report call statistics.
-  rtc::scoped_ptr<ChannelStatsObserver> stats_observer_;
-
-  // Not owned.
-  ReceiveStatisticsProxy* receive_stats_callback_ GUARDED_BY(crit_);
-  FrameCounts receive_frame_counts_ GUARDED_BY(crit_);
-  IncomingVideoStream* incoming_video_stream_ GUARDED_BY(crit_);
-  RtcpIntraFrameObserver* const intra_frame_observer_;
-  RtcpRttStats* const rtt_stats_;
-  PacedSender* const paced_sender_;
-  PacketRouter* const packet_router_;
-
-  const rtc::scoped_ptr<RtcpBandwidthObserver> bandwidth_observer_;
-  TransportFeedbackObserver* const transport_feedback_observer_;
-
-  rtc::PlatformThread decode_thread_;
-
-  int nack_history_size_sender_;
-  int max_nack_reordering_threshold_;
-  I420FrameCallback* pre_render_callback_ GUARDED_BY(crit_);
-
-  const rtc::scoped_ptr<ReportBlockStats> report_block_stats_sender_;
-
-  int64_t time_of_first_rtt_ms_ GUARDED_BY(crit_);
-  int64_t rtt_sum_ms_ GUARDED_BY(crit_);
-  int64_t last_rtt_ms_ GUARDED_BY(crit_);
-  size_t num_rtts_ GUARDED_BY(crit_);
-
-  // RtpRtcp modules, declared last as they use other members on construction.
-  const std::vector<RtpRtcp*> rtp_rtcp_modules_;
-  size_t num_active_rtp_rtcp_modules_ GUARDED_BY(crit_);
-};
-
-}  // namespace webrtc
-
-#endif  // WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_H_