Move video send/receive stream headers to webrtc/call.

webrtc/call/video_send_stream.h

 /*
  *  Copyright (c) 2013 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_SEND_STREAM_H_
-#define WEBRTC_VIDEO_SEND_STREAM_H_
+#ifndef WEBRTC_CALL_VIDEO_SEND_STREAM_H_
+#define WEBRTC_CALL_VIDEO_SEND_STREAM_H_
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
-#include <utility>
 
 #include "webrtc/api/call/transport.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/include/frame_callback.h"
 #include "webrtc/config.h"
 #include "webrtc/media/base/videosinkinterface.h"
 #include "webrtc/media/base/videosourceinterface.h"
 #include "webrtc/rtc_base/platform_file.h"
 
 namespace webrtc {
 
 class VideoEncoder;
 
 class VideoSendStream {
  public:
   struct StreamStats {
+    StreamStats();
+    ~StreamStats();
+
     std::string ToString() const;
 
     FrameCounts frame_counts;
     bool is_rtx = false;
     bool is_flexfec = false;
     int width = 0;
     int height = 0;
     // TODO(holmer): Move bitrate_bps out to the webrtc::Call layer.
     int total_bitrate_bps = 0;
     int retransmit_bitrate_bps = 0;
     int avg_delay_ms = 0;
     int max_delay_ms = 0;
     StreamDataCounters rtp_stats;
     RtcpPacketTypeCounter rtcp_packet_type_counts;
     RtcpStatistics rtcp_stats;
   };
 
   struct Stats {
+    Stats();
+    ~Stats();
     std::string ToString(int64_t time_ms) const;
     std::string encoder_implementation_name = "unknown";
     int input_frame_rate = 0;
     int encode_frame_rate = 0;
     int avg_encode_time_ms = 0;
     int encode_usage_percent = 0;
     uint32_t frames_encoded = 0;
     rtc::Optional<uint64_t> qp_sum;
     // Bitrate the encoder is currently configured to use due to bandwidth
     // limitations.
@@ skipping 11 matching lines @@
     // Total number of times resolution as been requested to be changed due to
     // CPU/quality adaptation.
     int number_of_cpu_adapt_changes = 0;
     int number_of_quality_adapt_changes = 0;
     std::map<uint32_t, StreamStats> substreams;
   };
 
   struct Config {
    public:
     Config() = delete;
-    Config(Config&&) = default;
-    explicit Config(Transport* send_transport)
-        : send_transport(send_transport) {}
+    Config(Config&&);
+    explicit Config(Transport* send_transport);
 
-    Config& operator=(Config&&) = default;
+    Config& operator=(Config&&);
     Config& operator=(const Config&) = delete;
 
+    ~Config();
+
     // Mostly used by tests.  Avoid creating copies if you can.
     Config Copy() const { return Config(*this); }
 
     std::string ToString() const;
 
     struct EncoderSettings {
       EncoderSettings() = default;
       EncoderSettings(std::string payload_name,
                       int payload_type,
                       VideoEncoder* encoder)
@@ skipping 14 matching lines @@
       // 30fps (for example) exactly.
       bool full_overuse_time = false;
 
       // Uninitialized VideoEncoder instance to be used for encoding. Will be
       // initialized from inside the VideoSendStream.
       VideoEncoder* encoder = nullptr;
     } encoder_settings;
 
     static const size_t kDefaultMaxPacketSize = 1500 - 40;  // TCP over IPv4.
     struct Rtp {
+      Rtp();
+      Rtp(const Rtp&);
+      ~Rtp();
       std::string ToString() const;
 
       std::vector<uint32_t> ssrcs;
 
       // See RtcpMode for description.
       RtcpMode rtcp_mode = RtcpMode::kCompound;
 
       // Max RTP packet size delivered to send transport from VideoEngine.
       size_t max_packet_size = kDefaultMaxPacketSize;
 
       // RTP header extensions to use for this send stream.
       std::vector<RtpExtension> extensions;
 
       // See NackConfig for description.
       NackConfig nack;
 
       // See UlpfecConfig for description.
       UlpfecConfig ulpfec;
 
       struct Flexfec {
+        Flexfec();
+        Flexfec(const Flexfec&);
+        ~Flexfec();
         // Payload type of FlexFEC. Set to -1 to disable sending FlexFEC.
         int payload_type = -1;
 
         // SSRC of FlexFEC stream.
         uint32_t ssrc = 0;
 
         // Vector containing a single element, corresponding to the SSRC of the
         // media stream being protected by this FlexFEC stream.
         // The vector MUST have size 1.
         //
         // TODO(brandtr): Update comment above when we support
         // multistream protection.
         std::vector<uint32_t> protected_media_ssrcs;
       } flexfec;
 
       // Settings for RTP retransmission payload format, see RFC 4588 for
       // details.
       struct Rtx {
+        Rtx();
+        Rtx(const Rtx&);
+        ~Rtx();
         std::string ToString() const;
         // SSRCs to use for the RTX streams.
         std::vector<uint32_t> ssrcs;
 
         // Payload type to use for the RTX stream.
         int payload_type = -1;
       } rtx;
 
       // RTCP CNAME, see RFC 3550.
       std::string c_name;
@@ skipping 25 matching lines @@
     // below the minimum configured bitrate. If this variable is false, the
     // stream may send at a rate higher than the estimated available bitrate.
     bool suspend_below_min_bitrate = false;
 
     // Enables periodic bandwidth probing in application-limited region.
     bool periodic_alr_bandwidth_probing = false;
 
    private:
     // Access to the copy constructor is private to force use of the Copy()
     // method for those exceptional cases where we do use it.
-    Config(const Config&) = default;
+    Config(const Config&);
   };
 
   // Starts stream activity.
   // When a stream is active, it can receive, process and deliver packets.
   virtual void Start() = 0;
   // Stops stream activity.
   // When a stream is stopped, it can't receive, process or deliver packets.
   virtual void Stop() = 0;
 
   // Based on the spec in
@@ skipping 39 matching lines @@
   inline void DisableEncodedFrameRecording() {
     EnableEncodedFrameRecording(std::vector<rtc::PlatformFile>(), 0);
   }
 
  protected:
   virtual ~VideoSendStream() {}
 };
 
 }  // namespace webrtc
 
-#endif  // WEBRTC_VIDEO_SEND_STREAM_H_
+#endif  // WEBRTC_CALL_VIDEO_SEND_STREAM_H_