Simplify SSRC usage inside ViEEncoder.

webrtc/video/vie_encoder.h

 /*
  *  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_VIE_ENCODER_H_
 #define WEBRTC_VIDEO_VIE_ENCODER_H_
 
-#include <map>
 #include <vector>
 
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/call/bitrate_allocator.h"
 #include "webrtc/common_types.h"
 #include "webrtc/frame_callback.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@@ skipping 11 matching lines @@
 class OveruseFrameDetector;
 class PacedSender;
 class PayloadRouter;
 class ProcessThread;
 class QMVideoSettingsCallback;
 class SendStatisticsProxy;
 class ViEBitrateObserver;
 class ViEEffectFilter;
 class VideoCodingModule;
 
 class ViEEncoder : public RtcpIntraFrameObserver,

[danilchap, 2016/02/19 19:25:56]

if you remove inheritence from RtcpIntraFrameObserver, then it it will be easier
to argue that OnReceivedIntraFrameRequest is called from EncoderStateFeedback
only that filters ssrcs.
Or even OnReceivedIntraFrameRequest can then take channel instead of ssrc,
eliminating ssrcs_ in VieEncoder_
also, ViEEncoder::OnLocalSsrcChanged could then be removed instead of DCHECKED.

[pbos-webrtc, 2016/02/19 19:30:07]

Done.

                    public VideoEncoderRateObserver,
                    public VCMPacketizationCallback,
                    public VCMSendStatisticsCallback,
                    public VideoCaptureCallback {
  public:
   friend class ViEBitrateObserver;
 
   ViEEncoder(uint32_t number_of_cores,
+             const std::vector<uint32_t>& ssrcs,
              ProcessThread* module_process_thread,
              SendStatisticsProxy* stats_proxy,
              I420FrameCallback* pre_encode_callback,
              OveruseFrameDetector* overuse_detector,
              PacedSender* pacer,
              PayloadRouter* payload_router,
              BitrateAllocator* bitrate_allocator);
   ~ViEEncoder();
 
   bool Init();
@@ skipping 45 matching lines @@
   // Implements VideoSendStatisticsCallback.
   int32_t SendStatistics(const uint32_t bit_rate,
                          const uint32_t frame_rate) override;
 
   // Implements RtcpIntraFrameObserver.
   void OnReceivedIntraFrameRequest(uint32_t ssrc) override;
   void OnReceivedSLI(uint32_t ssrc, uint8_t picture_id) override;
   void OnReceivedRPSI(uint32_t ssrc, uint64_t picture_id) override;
   void OnLocalSsrcChanged(uint32_t old_ssrc, uint32_t new_ssrc) override;
 
-  // Sets SSRCs for all streams.
-  void SetSsrcs(const std::vector<uint32_t>& ssrcs);
-
   void SetMinTransmitBitrate(int min_transmit_bitrate_kbps);
 
   // Lets the sender suspend video when the rate drops below
   // |threshold_bps|, and turns back on when the rate goes back up above
   // |threshold_bps| + |window_bps|.
   void SuspendBelowMinBitrate();
 
   // New-style callbacks, used by VideoSendStream.
   void RegisterPostEncodeImageCallback(
         EncodedImageCallback* post_encode_callback);
 
   int GetPaddingNeededBps() const;
 
  protected:
   // Called by BitrateObserver.
   void OnNetworkChanged(uint32_t bitrate_bps,
                         uint8_t fraction_lost,
                         int64_t round_trip_time_ms);
 
  private:
   bool EncoderPaused() const EXCLUSIVE_LOCKS_REQUIRED(data_cs_);
   void TraceFrameDropStart() EXCLUSIVE_LOCKS_REQUIRED(data_cs_);
   void TraceFrameDropEnd() EXCLUSIVE_LOCKS_REQUIRED(data_cs_);
 
   const uint32_t number_of_cores_;
+  const std::vector<uint32_t> ssrcs_;
 
   const rtc::scoped_ptr<VideoProcessing> vp_;
   const rtc::scoped_ptr<QMVideoSettingsCallback> qm_callback_;
   const rtc::scoped_ptr<VideoCodingModule> vcm_;
 
   rtc::CriticalSection data_cs_;
   rtc::scoped_ptr<BitrateObserver> bitrate_observer_;
 
   SendStatisticsProxy* const stats_proxy_;
   I420FrameCallback* const pre_encode_callback_;
   OveruseFrameDetector* const overuse_detector_;
   PacedSender* const pacer_;
   PayloadRouter* const send_payload_router_;
   BitrateAllocator* const bitrate_allocator_;
 
   // The time we last received an input frame or encoded frame. This is used to
   // track when video is stopped long enough that we also want to stop sending
   // padding.
   int64_t time_of_last_frame_activity_ms_ GUARDED_BY(data_cs_);
   VideoCodec encoder_config_ GUARDED_BY(data_cs_);
   int min_transmit_bitrate_kbps_ GUARDED_BY(data_cs_);
   uint32_t last_observed_bitrate_bps_ GUARDED_BY(data_cs_);
   int target_delay_ms_ GUARDED_BY(data_cs_);
   bool network_is_transmitting_ GUARDED_BY(data_cs_);
   bool encoder_paused_ GUARDED_BY(data_cs_);
   bool encoder_paused_and_dropped_frame_ GUARDED_BY(data_cs_);
-  std::map<unsigned int, int64_t> time_last_intra_request_ms_
-      GUARDED_BY(data_cs_);
+  std::vector<int64_t> time_last_intra_request_ms_ GUARDED_BY(data_cs_);
 
   ProcessThread* module_process_thread_;
 
   bool has_received_sli_ GUARDED_BY(data_cs_);
   uint8_t picture_id_sli_ GUARDED_BY(data_cs_);
   bool has_received_rpsi_ GUARDED_BY(data_cs_);
   uint64_t picture_id_rpsi_ GUARDED_BY(data_cs_);
-  std::map<uint32_t, int> ssrc_streams_ GUARDED_BY(data_cs_);
 
   bool video_suspended_ GUARDED_BY(data_cs_);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_VIDEO_VIE_ENCODER_H_