Add a flags field to video timing 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.
 */
 
@@ skipping 213 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;
-  bool is_timing_frame = false;
+  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()) {
       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()) {
@@ skipping 22 matching lines @@
 
     // Check if it's time to send a timing frame.
     int64_t timing_frame_delay_ms =
         encoded_image.capture_time_ms_ - last_timing_frame_time_ms_;
     // Trigger threshold if it's a first frame, too long passed since the last
     // timing frame, or we already sent timing frame on a different simulcast
     // stream with the same capture time.
     if (last_timing_frame_time_ms_ == -1 ||
         timing_frame_delay_ms >= timing_frames_thresholds_.delay_ms ||
         timing_frame_delay_ms == 0) {
-      is_timing_frame = true;
+      timing_flags = TimingFrameFlags::kTriggeredByTimer;
       last_timing_frame_time_ms_ = encoded_image.capture_time_ms_;
     }
 
     // Outliers trigger timing frames, but do not affect scheduled timing
     // frames.
     if (outlier_frame_size && encoded_image._length >= *outlier_frame_size) {
-      is_timing_frame = true;
+      if (timing_flags == TimingFrameFlags::kInvalid)
+        timing_flags = 0;
+      timing_flags |= TimingFrameFlags::kTriggeredBySize;
     }
   }
 
   // If encode start is not available that means that encoder uses internal
   // source. In that case capture timestamp may be from a different clock with a
   // 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 (is_timing_frame && encode_start_ms) {
+  if (timing_flags != TimingFrameFlags::kInvalid && encode_start_ms) {
     encoded_image.SetEncodeTime(*encode_start_ms, rtc::TimeMillis());
   }
+  encoded_image.timing_.flags = timing_flags;
 
   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