C++11 in-class member initialization in Call configs.

webrtc/video_receive_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.
  */
 
@@ skipping 18 matching lines @@
 enum RtcpMode { kRtcpCompound, kRtcpReducedSize };
 }  // namespace newapi
 
 class VideoDecoder;
 
 class VideoReceiveStream {
  public:
   // TODO(mflodman) Move all these settings to VideoDecoder and move the
   // declaration to common_types.h.
   struct Decoder {
-    Decoder()
-        : decoder(NULL),
-          payload_type(0),
-          is_renderer(false),
-          expected_delay_ms(0) {}
     std::string ToString() const;
 
     // The actual decoder instance.
-    VideoDecoder* decoder;
+    VideoDecoder* decoder = nullptr;
 
     // Received RTP packets with this payload type will be sent to this decoder
     // instance.
-    int payload_type;
+    int payload_type = 0;
 
     // Name of the decoded payload (such as VP8). Maps back to the depacketizer
     // used to unpack incoming packets.
     std::string payload_name;
 
     // 'true' if the decoder handles rendering as well.
-    bool is_renderer;
+    bool is_renderer = false;
 
     // The expected delay for decoding and rendering, i.e. the frame will be
     // delivered this many milliseconds, if possible, earlier than the ideal
     // render time.
     // Note: Ignored if 'renderer' is false.
-    int expected_delay_ms;
+    int expected_delay_ms = 0;
   };
 
   struct Stats {
     int network_frame_rate = 0;
     int decode_frame_rate = 0;
     int render_frame_rate = 0;
 
     // Decoder stats.
     FrameCounts frame_counts;
     int decode_ms = 0;
     int max_decode_ms = 0;
     int current_delay_ms = 0;
     int target_delay_ms = 0;
     int jitter_buffer_ms = 0;
     int min_playout_delay_ms = 0;
     int render_delay_ms = 10;
 
     int total_bitrate_bps = 0;
     int discarded_packets = 0;
 
     uint32_t ssrc = 0;
     std::string c_name;
     StreamDataCounters rtp_stats;
     RtcpPacketTypeCounter rtcp_packet_type_counts;
     RtcpStatistics rtcp_stats;
   };
 
   struct Config {
-    Config()
-        : renderer(NULL),
-          render_delay_ms(10),
-          audio_channel_id(-1),
-          pre_decode_callback(NULL),
-          pre_render_callback(NULL),
-          target_delay_ms(0) {}
     std::string ToString() const;
 
     // Decoders for every payload that we can receive.
     std::vector<Decoder> decoders;
 
     // Receive-stream specific RTP settings.
     struct Rtp {
-      Rtp()
-          : remote_ssrc(0),
-            local_ssrc(0),
-            rtcp_mode(newapi::kRtcpCompound),
-            remb(false) {}
       std::string ToString() const;
 
       // Synchronization source (stream identifier) to be received.
-      uint32_t remote_ssrc;
+      uint32_t remote_ssrc = 0;
       // Sender SSRC used for sending RTCP (such as receiver reports).
-      uint32_t local_ssrc;
+      uint32_t local_ssrc = 0;
 
       // See RtcpMode for description.
-      newapi::RtcpMode rtcp_mode;
+      newapi::RtcpMode rtcp_mode = newapi::kRtcpCompound;
 
       // Extended RTCP settings.
       struct RtcpXr {
-        RtcpXr() : receiver_reference_time_report(false) {}
-
         // True if RTCP Receiver Reference Time Report Block extension
         // (RFC 3611) should be enabled.
-        bool receiver_reference_time_report;
+        bool receiver_reference_time_report = false;
       } rtcp_xr;
 
       // See draft-alvestrand-rmcat-remb for information.
-      bool remb;
+      bool remb = false;
 
       // See NackConfig for description.
       NackConfig nack;
 
       // See FecConfig for description.
       FecConfig fec;
 
       // RTX settings for incoming video payloads that may be received. RTX is
       // disabled if there's no config present.
       struct Rtx {
-        Rtx() : ssrc(0), payload_type(0) {}
-
         // SSRCs to use for the RTX streams.
-        uint32_t ssrc;
+        uint32_t ssrc = 0;
 
         // Payload type to use for the RTX stream.
-        int payload_type;
+        int payload_type = 0;
       };
 
       // Map from video RTP payload type -> RTX config.
       typedef std::map<int, Rtx> RtxMap;
       RtxMap rtx;
 
       // RTP header extensions used for the received stream.
       std::vector<RtpExtension> extensions;
     } rtp;
 
-    // VideoRenderer will be called for each decoded frame. 'NULL' disables
+    // VideoRenderer will be called for each decoded frame. 'nullptr' disables
     // rendering of this stream.
-    VideoRenderer* renderer;
+    VideoRenderer* renderer = nullptr;
 
     // Expected delay needed by the renderer, i.e. the frame will be delivered
     // this many milliseconds, if possible, earlier than the ideal render time.
     // Only valid if 'renderer' is set.
-    int render_delay_ms;
+    int render_delay_ms = 10;
 
     // Audio channel corresponding to this video stream, used for audio/video
     // synchronization. 'audio_channel_id' is ignored if no VoiceEngine is set
     // when creating the VideoEngine instance. '-1' disables a/v sync.
-    int audio_channel_id;
+    int audio_channel_id = -1;
 
     // Called for each incoming video frame, i.e. in encoded state. E.g. used
     // when
-    // saving the stream to a file. 'NULL' disables the callback.
-    EncodedFrameObserver* pre_decode_callback;
+    // saving the stream to a file. 'nullptr' disables the callback.
+    EncodedFrameObserver* pre_decode_callback = nullptr;
 
     // Called for each decoded frame. E.g. used when adding effects to the
     // decoded
-    // stream. 'NULL' disables the callback.
-    I420FrameCallback* pre_render_callback;
+    // stream. 'nullptr' disables the callback.
+    I420FrameCallback* pre_render_callback = nullptr;
 
     // Target delay in milliseconds. A positive value indicates this stream is
     // used for streaming instead of a real-time call.
-    int target_delay_ms;
+    int target_delay_ms = 0;
   };
 
   virtual void Start() = 0;
   virtual void Stop() = 0;
 
   // TODO(pbos): Add info on currently-received codec to Stats.
   virtual Stats GetStats() const = 0;
 
  protected:
   virtual ~VideoReceiveStream() {}
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_VIDEO_RECEIVE_STREAM_H_