Simplify SSRC usage inside ViEEncoder.

webrtc/video/vie_encoder.cc

 /*
  *  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.
  */
 
@@ skipping 87 matching lines @@
   virtual void OnNetworkChanged(uint32_t bitrate_bps,
                                 uint8_t fraction_lost,
                                 int64_t rtt) {
     owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt);
   }
  private:
   ViEEncoder* owner_;
 };
 
 ViEEncoder::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)
     : number_of_cores_(number_of_cores),
+      ssrcs_(ssrcs),
       vp_(VideoProcessing::Create()),
       qm_callback_(new QMVideoSettingsCallback(vp_.get())),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      this,
                                      qm_callback_.get())),
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),
       overuse_detector_(overuse_detector),
       pacer_(pacer),
       send_payload_router_(payload_router),
       bitrate_allocator_(bitrate_allocator),
       time_of_last_frame_activity_ms_(0),
       encoder_config_(),
       min_transmit_bitrate_kbps_(0),
       last_observed_bitrate_bps_(0),
       target_delay_ms_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
+      time_last_intra_request_ms_(ssrcs.size(), -1),
       module_process_thread_(module_process_thread),
       has_received_sli_(false),
       picture_id_sli_(0),
       has_received_rpsi_(false),
       picture_id_rpsi_(0),
       video_suspended_(false) {
   bitrate_observer_.reset(new ViEBitrateObserver(this));
   module_process_thread_->RegisterModule(vcm_.get());
 }
 
@@ skipping 343 matching lines @@
                                 uint64_t picture_id) {
   rtc::CritScope lock(&data_cs_);
   picture_id_rpsi_ = picture_id;
   has_received_rpsi_ = true;
 }
 
 void ViEEncoder::OnReceivedIntraFrameRequest(uint32_t ssrc) {
   // Key frame request from remote side, signal to VCM.
   TRACE_EVENT0("webrtc", "OnKeyFrameRequest");
 
-  int idx = 0;
-  {
-    rtc::CritScope lock(&data_cs_);
-    auto stream_it = ssrc_streams_.find(ssrc);
-    if (stream_it == ssrc_streams_.end()) {
-      LOG_F(LS_WARNING) << "ssrc not found: " << ssrc << ", map size "
-                        << ssrc_streams_.size();
-      return;
+  for (size_t i = 0; i < ssrcs_.size(); ++i) {
+    if (ssrcs_[i] != ssrc)
+      continue;
+    int64_t now_ms = TickTime::MillisecondTimestamp();
+    {
+      rtc::CritScope lock(&data_cs_);
+      if (time_last_intra_request_ms_[i] + kMinKeyFrameRequestIntervalMs >

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

no check if time_last_intra_request_ms_[i] is valid (!= -1)
Silently relying that now_ms >> kMinIntervalMs?

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

We're relying on now_ms >= 0 (pretty much everywhere), and at the -1 case is off
by one, so it doesn't really matter that we limit this to 300 or 301 ms. Either
I update the default to 0 or ignore this, I don't wanna have != -1 && ...

WDYT?

[danilchap, 2016/02/19 19:39:36]

Just want to be sure being implicit here is intended, not overlooked.

+          now_ms) {
+        return;
+      }
+      time_last_intra_request_ms_[i] = now_ms;
     }
-    std::map<unsigned int, int64_t>::iterator time_it =
-        time_last_intra_request_ms_.find(ssrc);
-    if (time_it == time_last_intra_request_ms_.end()) {
-      time_last_intra_request_ms_[ssrc] = 0;
-    }
-
-    int64_t now = TickTime::MillisecondTimestamp();
-    if (time_last_intra_request_ms_[ssrc] + kMinKeyFrameRequestIntervalMs
-        > now) {
-      return;
-    }
-    time_last_intra_request_ms_[ssrc] = now;
-    idx = stream_it->second;
+    vcm_->IntraFrameRequest(static_cast<int>(i));
+    return;
   }
-  // Release the critsect before triggering key frame.
-  vcm_->IntraFrameRequest(idx);
+  RTC_NOTREACHED() << "Should not receive keyframe requests on unknown SSRCs.";
 }
 
 void ViEEncoder::OnLocalSsrcChanged(uint32_t old_ssrc, uint32_t new_ssrc) {
-  rtc::CritScope lock(&data_cs_);
-  std::map<unsigned int, int>::iterator it = ssrc_streams_.find(old_ssrc);
-  if (it == ssrc_streams_.end()) {
-    return;
-  }
-
-  ssrc_streams_[new_ssrc] = it->second;
-  ssrc_streams_.erase(it);
-
-  std::map<unsigned int, int64_t>::iterator time_it =
-      time_last_intra_request_ms_.find(old_ssrc);
-  int64_t last_intra_request_ms = 0;
-  if (time_it != time_last_intra_request_ms_.end()) {
-    last_intra_request_ms = time_it->second;
-    time_last_intra_request_ms_.erase(time_it);
-  }
-  time_last_intra_request_ms_[new_ssrc] = last_intra_request_ms;
-}
-
-void ViEEncoder::SetSsrcs(const std::vector<uint32_t>& ssrcs) {
-  rtc::CritScope lock(&data_cs_);
-  ssrc_streams_.clear();
-  time_last_intra_request_ms_.clear();
-  int idx = 0;
-  for (uint32_t ssrc : ssrcs) {
-    ssrc_streams_[ssrc] = idx++;
-  }
+  RTC_NOTREACHED();
 }
 
 void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) {
   assert(min_transmit_bitrate_kbps >= 0);
   rtc::CritScope lock(&data_cs_);
   min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
 }
 
 // Called from ViEBitrateObserver.
 void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
                                   int64_t round_trip_time_ms) {
   LOG(LS_VERBOSE) << "OnNetworkChanged, bitrate" << bitrate_bps
                   << " packet loss " << static_cast<int>(fraction_lost)
                   << " rtt " << round_trip_time_ms;
   RTC_DCHECK(send_payload_router_ != NULL);
   vcm_->SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms);
   bool video_is_suspended = vcm_->VideoSuspended();
   bool video_suspension_changed;
   VideoCodec send_codec;
-  uint32_t first_ssrc;
   {
     rtc::CritScope lock(&data_cs_);
     last_observed_bitrate_bps_ = bitrate_bps;
     video_suspension_changed = video_suspended_ != video_is_suspended;
     video_suspended_ = video_is_suspended;
     send_codec = encoder_config_;
-    first_ssrc = ssrc_streams_.begin()->first;
   }
 
   SimulcastStream* stream_configs = send_codec.simulcastStream;
   // Allocate the bandwidth between the streams.
   std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates(
       bitrate_bps, stream_configs, send_codec.numberOfSimulcastStreams);
   send_payload_router_->SetTargetSendBitrates(stream_bitrates);
 
   if (!video_suspension_changed)
     return;
   // Video suspend-state changed, inform codec observer.
   LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended
-               << " for ssrc " << first_ssrc;
+               << " for ssrc " << ssrcs_[0];
   if (stats_proxy_)
     stats_proxy_->OnSuspendChange(video_is_suspended);
 }
 
 void ViEEncoder::SuspendBelowMinBitrate() {
   vcm_->SuspendBelowMinBitrate();
   bitrate_allocator_->EnforceMinBitrate(false);
 }
 
 void ViEEncoder::RegisterPostEncodeImageCallback(
@@ skipping 13 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vp_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc