Piggybacking simulcast id and ALR experiment id into video content type extension.

webrtc/modules/video_coding/generic_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.
 */
 
 #include "webrtc/modules/video_coding/generic_encoder.h"
 
 #include <vector>
 
 #include "webrtc/api/video/i420_buffer.h"
+#include "webrtc/modules/pacing/alr_detector.h"
 #include "webrtc/modules/video_coding/encoded_frame.h"
 #include "webrtc/modules/video_coding/media_optimization.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/optional.h"
 #include "webrtc/rtc_base/timeutils.h"
 #include "webrtc/rtc_base/trace_event.h"
+#include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace webrtc {
 
 VCMGenericEncoder::VCMGenericEncoder(
     VideoEncoder* encoder,
     VCMEncodedFrameCallback* encoded_frame_callback,
     bool internal_source)
     : encoder_(encoder),
       vcm_encoded_frame_callback_(encoded_frame_callback),
       internal_source_(internal_source),
@@ skipping 143 matching lines @@
 }
 
 VCMEncodedFrameCallback::VCMEncodedFrameCallback(
     EncodedImageCallback* post_encode_callback,
     media_optimization::MediaOptimization* media_opt)
     : internal_source_(false),
       post_encode_callback_(post_encode_callback),
       media_opt_(media_opt),
       framerate_(1),
       last_timing_frame_time_ms_(-1),
-      timing_frames_thresholds_({-1, 0}) {}
+      timing_frames_thresholds_({-1, 0}) {
+  rtc::Optional<AlrDetector::AlrExperimentSettings> experiment_settings =
+      AlrDetector::ParseAlrSettingsFromFieldTrial(
+          AlrDetector::kStrictPacingAndProbingExperimentName);
+  if (experiment_settings) {
+    experiment_groups_[0] = experiment_settings->group_id + 1;
+  } else {
+    experiment_groups_[0] = 0;
+  }
+  experiment_settings = AlrDetector::ParseAlrSettingsFromFieldTrial(
+      AlrDetector::kScreenshareProbingBweExperimentName);
+  if (experiment_settings) {
+    experiment_groups_[1] = experiment_settings->group_id + 1;
+  } else {
+    experiment_groups_[1] = 0;
+  }
+}
 
 VCMEncodedFrameCallback::~VCMEncodedFrameCallback() {}
 
 void VCMEncodedFrameCallback::OnTargetBitrateChanged(
     size_t bitrate_bytes_per_second,
     size_t simulcast_svc_idx) {
   rtc::CritScope crit(&timing_params_lock_);
   if (timing_frames_info_.size() < simulcast_svc_idx + 1)
     timing_frames_info_.resize(simulcast_svc_idx + 1);
   timing_frames_info_[simulcast_svc_idx].target_bitrate_bytes_per_sec =
@@ skipping 27 matching lines @@
   } else if (codec_specific->codecType == kVideoCodecVP8) {
     simulcast_svc_idx = codec_specific->codecSpecific.VP8.simulcastIdx;
   } else if (codec_specific->codecType == kVideoCodecGeneric) {
     simulcast_svc_idx = codec_specific->codecSpecific.generic.simulcast_idx;
   } else if (codec_specific->codecType == kVideoCodecH264) {
     // TODO(ilnik): When h264 simulcast is landed, extract simulcast idx here.
   }
 
   rtc::Optional<size_t> outlier_frame_size;
   rtc::Optional<int64_t> encode_start_ms;
+  size_t num_simulcast_svc_streams = 1;
   uint8_t timing_flags = TimingFrameFlags::kInvalid;
   {
     rtc::CritScope crit(&timing_params_lock_);
 
     // Encoders with internal sources do not call OnEncodeStarted and
     // OnFrameRateChanged. |timing_frames_info_| may be not filled here.
-    if (simulcast_svc_idx < timing_frames_info_.size()) {
+    num_simulcast_svc_streams = timing_frames_info_.size();
+    if (simulcast_svc_idx < num_simulcast_svc_streams) {
       auto encode_start_map =
           &timing_frames_info_[simulcast_svc_idx].encode_start_time_ms;
       auto it = encode_start_map->find(encoded_image.capture_time_ms_);
       if (it != encode_start_map->end()) {
         encode_start_ms.emplace(it->second);
         // Assuming all encoders do not reorder frames within single stream,
         // there may be some dropped frames with smaller timestamps. These
         // should be purged.
         encode_start_map->erase(encode_start_map->begin(), it);
         encode_start_map->erase(it);
@@ skipping 41 matching lines @@
   // drift relative to rtc::TimeMillis(). We can't use it for Timing frames,
   // because to being sent in the network capture time required to be less than
   // all the other timestamps.
   if (timing_flags != TimingFrameFlags::kInvalid && encode_start_ms) {
     encoded_image.SetEncodeTime(*encode_start_ms, rtc::TimeMillis());
     encoded_image.timing_.flags = timing_flags;
   } else {
     encoded_image.timing_.flags = TimingFrameFlags::kInvalid;
   }
 
+  // Piggyback ALR experiment group id and simulcast id into the content type.
+  uint8_t experiment_id =
+      experiment_groups_[videocontenttypehelpers::IsScreenshare(
+          encoded_image.content_type_)];
+
+  // TODO(ilnik): This will force content type extension to be present even
+  // for realtime video. At the expense of miniscule overhead we will get
+  // sliced receive statistics.
+  RTC_CHECK(videocontenttypehelpers::SetExperimentId(
+      &encoded_image.content_type_, experiment_id));
+  // We count simulcast streams from 1 on the wire. That's why we set simulcast
+  // id in content type to +1 of that is actual simulcast index. This is because
+  // value 0 on the wire is reserved for 'no simulcast stream specified'.
+  RTC_CHECK(videocontenttypehelpers::SetSimulcastId(
+      &encoded_image.content_type_,
+      static_cast<uint8_t>(simulcast_svc_idx + 1)));
+
   Result result = post_encode_callback_->OnEncodedImage(
       encoded_image, codec_specific, fragmentation_header);
   if (result.error != Result::OK)
     return result;
 
   if (media_opt_) {
     media_opt_->UpdateWithEncodedData(encoded_image);
     if (internal_source_) {
       // Signal to encoder to drop next frame.
       result.drop_next_frame = media_opt_->DropFrame();
     }
   }
   return result;
 }
 
 }  // namespace webrtc