Implement timing frames.

webrtc/modules/video_coding/codecs/vp8/vp8_impl.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 147 matching lines @@
 
 VP8EncoderImpl::VP8EncoderImpl()
     : use_gf_boost_(webrtc::field_trial::IsEnabled(kVp8GfBoostFieldTrial)),
       encoded_complete_callback_(nullptr),
       inited_(false),
       timestamp_(0),
       qp_max_(56),  // Setting for max quantizer.
       cpu_speed_default_(-6),
       number_of_cores_(0),
       rc_max_intra_target_(0),
-      key_frame_request_(kMaxSimulcastStreams, false) {
+      key_frame_request_(kMaxSimulcastStreams, false),
+      last_timing_frame_time_ms_(0) {
   Random random(rtc::TimeMicros());
   picture_id_.reserve(kMaxSimulcastStreams);
   for (int i = 0; i < kMaxSimulcastStreams; ++i) {
     picture_id_.push_back(random.Rand<uint16_t>() & 0x7FFF);
     tl0_pic_idx_.push_back(random.Rand<uint8_t>());
   }
   temporal_layers_.reserve(kMaxSimulcastStreams);
   raw_images_.reserve(kMaxSimulcastStreams);
   encoded_images_.reserve(kMaxSimulcastStreams);
   send_stream_.reserve(kMaxSimulcastStreams);
@@ skipping 482 matching lines @@
                            const CodecSpecificInfo* codec_specific_info,
                            const std::vector<FrameType>* frame_types) {
   RTC_DCHECK_EQ(frame.width(), codec_.width);
   RTC_DCHECK_EQ(frame.height(), codec_.height);
 
   if (!inited_)
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   if (encoded_complete_callback_ == NULL)
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
 
+  int64_t encode_start_ms = rtc::TimeMillis();
+
   rtc::scoped_refptr<VideoFrameBuffer> input_image = frame.video_frame_buffer();
   // Since we are extracting raw pointers from |input_image| to
   // |raw_images_[0]|, the resolution of these frames must match.
   RTC_DCHECK_EQ(input_image->width(), raw_images_[0].d_w);
   RTC_DCHECK_EQ(input_image->height(), raw_images_[0].d_h);
 
   // Image in vpx_image_t format.
   // Input image is const. VP8's raw image is not defined as const.
   raw_images_[0].planes[VPX_PLANE_Y] =
       const_cast<uint8_t*>(input_image->DataY());
@@ skipping 101 matching lines @@
                                duration, 0, VPX_DL_REALTIME);
   // Reset specific intra frame thresholds, following the key frame.
   if (send_key_frame) {
     vpx_codec_control(&(encoders_[0]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                       rc_max_intra_target_);
   }
   if (error)
     return WEBRTC_VIDEO_CODEC_ERROR;
   timestamp_ += duration;
   // Examines frame timestamps only.
-  return GetEncodedPartitions(tl_configs, frame);
+  return GetEncodedPartitions(tl_configs, frame, encode_start_ms);
 }
 
 void VP8EncoderImpl::PopulateCodecSpecific(
     CodecSpecificInfo* codec_specific,
     const TemporalLayers::FrameConfig& tl_config,
     const vpx_codec_cx_pkt_t& pkt,
     int stream_idx,
     uint32_t timestamp) {
   assert(codec_specific != NULL);
   codec_specific->codecType = kVideoCodecVP8;
   codec_specific->codec_name = ImplementationName();
   CodecSpecificInfoVP8* vp8Info = &(codec_specific->codecSpecific.VP8);
   vp8Info->pictureId = picture_id_[stream_idx];
   vp8Info->simulcastIdx = stream_idx;
   vp8Info->keyIdx = kNoKeyIdx;  // TODO(hlundin) populate this
   vp8Info->nonReference = (pkt.data.frame.flags & VPX_FRAME_IS_DROPPABLE) != 0;
   temporal_layers_[stream_idx]->PopulateCodecSpecific(
       (pkt.data.frame.flags & VPX_FRAME_IS_KEY) != 0, tl_config, vp8Info,
       timestamp);
   // Prepare next.
   picture_id_[stream_idx] = (picture_id_[stream_idx] + 1) & 0x7FFF;
 }
 
 int VP8EncoderImpl::GetEncodedPartitions(
     const TemporalLayers::FrameConfig tl_configs[],
-    const VideoFrame& input_image) {
+    const VideoFrame& input_image,
+    int64_t encode_start_ms) {
   int bw_resolutions_disabled =
       (encoders_.size() > 1) ? NumStreamsDisabled(send_stream_) : -1;
 
+  bool is_time_for_timing_frame =
+      input_image.render_time_ms() - last_timing_frame_time_ms_ >=
+      codec_.timingFramesDelayMs;
+  if (is_time_for_timing_frame)
+    last_timing_frame_time_ms_ = input_image.render_time_ms();
+
   int stream_idx = static_cast<int>(encoders_.size()) - 1;
   int result = WEBRTC_VIDEO_CODEC_OK;
   for (size_t encoder_idx = 0; encoder_idx < encoders_.size();
        ++encoder_idx, --stream_idx) {
     vpx_codec_iter_t iter = NULL;
     int part_idx = 0;
     encoded_images_[encoder_idx]._length = 0;
     encoded_images_[encoder_idx]._frameType = kVideoFrameDelta;
     RTPFragmentationHeader frag_info;
     // kTokenPartitions is number of bits used.
@@ skipping 39 matching lines @@
       }
     }
     encoded_images_[encoder_idx]._timeStamp = input_image.timestamp();
     encoded_images_[encoder_idx].capture_time_ms_ =
         input_image.render_time_ms();
     encoded_images_[encoder_idx].rotation_ = input_image.rotation();
     encoded_images_[encoder_idx].content_type_ =
         (codec_.mode == kScreensharing) ? VideoContentType::SCREENSHARE
                                         : VideoContentType::UNSPECIFIED;
 
+    if (is_time_for_timing_frame ||
+        encoded_images_[encoder_idx]._length >=
+            codec_.minFrameSizeToForceTimingFrameBytes) {
+      encoded_images_[encoder_idx].timing_.is_timing_frame = true;
+      encoded_images_[encoder_idx].timing_.encode_start_ms = encode_start_ms;
+      encoded_images_[encoder_idx].timing_.encode_finish_ms = rtc::TimeMillis();
+    } else {
+      encoded_images_[encoder_idx].timing_.is_timing_frame = false;
+    }
+
     int qp = -1;
     vpx_codec_control(&encoders_[encoder_idx], VP8E_GET_LAST_QUANTIZER_64, &qp);
     temporal_layers_[stream_idx]->FrameEncoded(
         encoded_images_[encoder_idx]._length, qp);
     if (send_stream_[stream_idx]) {
       if (encoded_images_[encoder_idx]._length > 0) {
         TRACE_COUNTER_ID1("webrtc", "EncodedFrameSize", encoder_idx,
                           encoded_images_[encoder_idx]._length);
         encoded_images_[encoder_idx]._encodedHeight =
             codec_.simulcastStream[stream_idx].height;
@@ skipping 257 matching lines @@
   buffer_pool_.Release();
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP8DecoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
 }  // namespace webrtc