Recreate FlexfecReceiveStream separately from VideoReceiveStream.

webrtc/media/engine/webrtcvideoengine2.h

 /*
  *  Copyright (c) 2014 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 173 matching lines @@
     ADAPTREASON_NONE = 0,
     ADAPTREASON_CPU = 1,
     ADAPTREASON_BANDWIDTH = 2,
   };
 
  private:
   class WebRtcVideoReceiveStream;
   struct VideoCodecSettings {
     VideoCodecSettings();
 
+    // Checks if all members of |*this| are equal to the corresponding members
+    // of |other|.
     bool operator==(const VideoCodecSettings& other) const;
     bool operator!=(const VideoCodecSettings& other) const;
 
+    // Checks if all members of |a|, except |flexfec_payload_type|, are equal
+    // to the corresponding members of |b|.
+    static bool EqualsDisregardingFlexfec(const VideoCodecSettings& a,
+                                          const VideoCodecSettings& b);
+
     VideoCodec codec;
     webrtc::UlpfecConfig ulpfec;
     int flexfec_payload_type;
     int rtx_payload_type;
   };
 
   struct ChangedSendParameters {
     // These optionals are unset if not changed.
     rtc::Optional<VideoCodecSettings> codec;
     rtc::Optional<std::vector<webrtc::RtpExtension>> rtp_header_extensions;
     rtc::Optional<int> max_bandwidth_bps;
     rtc::Optional<bool> conference_mode;
     rtc::Optional<webrtc::RtcpMode> rtcp_mode;
   };
 
   struct ChangedRecvParameters {
     // These optionals are unset if not changed.
     rtc::Optional<std::vector<VideoCodecSettings>> codec_settings;
     rtc::Optional<std::vector<webrtc::RtpExtension>> rtp_header_extensions;
+    // Keep track of the FlexFEC payload type separately from |codec_settings|.
+    // This allows us to recreate the FlexfecReceiveStream separately from the
+    // VideoReceiveStream when the FlexFEC payload type is changed.
+    rtc::Optional<int> flexfec_payload_type;
   };
 
   bool GetChangedSendParameters(const VideoSendParameters& params,
                                 ChangedSendParameters* changed_params) const;
   bool GetChangedRecvParameters(const VideoRecvParameters& params,
                                 ChangedRecvParameters* changed_params) const;
 
   void SetMaxSendBandwidth(int bps);
 
   void ConfigureReceiverRtp(
@@ skipping 174 matching lines @@
       AllocatedDecoder(webrtc::VideoDecoder* decoder,
                        webrtc::VideoCodecType type,
                        bool external);
       webrtc::VideoDecoder* decoder;
       // Decoder wrapped into a fallback decoder to permit software fallback.
       webrtc::VideoDecoder* external_decoder;
       webrtc::VideoCodecType type;
       bool external;
     };
 
-    void RecreateWebRtcStream();
+    void RecreateWebRtcVideoStream();
+    void MaybeRecreateWebRtcFlexfecStream();
 
     void ConfigureCodecs(const std::vector<VideoCodecSettings>& recv_codecs,
                          std::vector<AllocatedDecoder>* old_codecs);
+    void ConfigureFlexfecCodec(int flexfec_payload_type);
     AllocatedDecoder CreateOrReuseVideoDecoder(
         std::vector<AllocatedDecoder>* old_decoder,
         const VideoCodec& codec);
     void ClearDecoders(std::vector<AllocatedDecoder>* allocated_decoders);
 
     std::string GetCodecNameFromPayloadType(int payload_type);
 
     webrtc::Call* const call_;
     StreamParams stream_params_;
 
@@ skipping 29 matching lines @@
   bool SendRtcp(const uint8_t* data, size_t len) override;
 
   static std::vector<VideoCodecSettings> MapCodecs(
       const std::vector<VideoCodec>& codecs);
   // Select what video codec will be used for sending, i.e. what codec is used
   // for local encoding, based on supported remote codecs. The first remote
   // codec that is supported locally will be selected.
   rtc::Optional<VideoCodecSettings> SelectSendVideoCodec(
       const std::vector<VideoCodecSettings>& remote_mapped_codecs) const;
 
-  static bool ReceiveCodecsHaveChanged(std::vector<VideoCodecSettings> before,
-                                       std::vector<VideoCodecSettings> after);
+  static bool NonFlexfecReceiveCodecsHaveChanged(
+      std::vector<VideoCodecSettings> before,
+      std::vector<VideoCodecSettings> after);
 
   void FillSenderStats(VideoMediaInfo* info, bool log_stats);
   void FillReceiverStats(VideoMediaInfo* info, bool log_stats);
   void FillBandwidthEstimationStats(const webrtc::Call::Stats& stats,
                                     VideoMediaInfo* info);
   void FillSendAndReceiveCodecStats(VideoMediaInfo* video_media_info);
 
   rtc::ThreadChecker thread_checker_;
 
   uint32_t rtcp_receiver_report_ssrc_;
@@ skipping 14 matching lines @@
   std::set<uint32_t> send_ssrcs_ GUARDED_BY(stream_crit_);
   std::set<uint32_t> receive_ssrcs_ GUARDED_BY(stream_crit_);
 
   rtc::Optional<VideoCodecSettings> send_codec_;
   rtc::Optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
 
   WebRtcVideoEncoderFactory* const external_encoder_factory_;
   WebRtcVideoDecoderFactory* const external_decoder_factory_;
   std::vector<VideoCodecSettings> recv_codecs_;
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
+  // See reason for keeping track of the FlexFEC payload type separately in
+  // comment in WebRtcVideoChannel2::ChangedRecvParameters.
+  int recv_flexfec_payload_type_;
   webrtc::Call::Config::BitrateConfig bitrate_config_;
   // TODO(deadbeef): Don't duplicate information between
   // send_params/recv_params, rtp_extensions, options, etc.
   VideoSendParameters send_params_;
   VideoOptions default_send_options_;
   VideoRecvParameters recv_params_;
   int64_t last_stats_log_ms_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE2_H_