Implement timing frames.

webrtc/modules/video_coding/generic_decoder.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/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/generic_decoder.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 VCMDecodedFrameCallback::VCMDecodedFrameCallback(VCMTiming* timing,
                                                  Clock* clock)
     : _clock(clock),
       _timing(timing),
       _timestampMap(kDecoderFrameMemoryLength),
-      _lastReceivedPictureID(0) {}
+      _lastReceivedPictureID(0) {
+  ntp_offset_ =
+      _clock->CurrentNtpInMilliseconds() - _clock->TimeInMilliseconds();
+}
 
 VCMDecodedFrameCallback::~VCMDecodedFrameCallback() {
 }
 
 void VCMDecodedFrameCallback::SetUserReceiveCallback(
     VCMReceiveCallback* receiveCallback) {
   RTC_DCHECK(construction_thread_.CalledOnValidThread());
   RTC_DCHECK((!_receiveCallback && receiveCallback) ||
              (_receiveCallback && !receiveCallback));
   _receiveCallback = receiveCallback;
@@ skipping 40 matching lines @@
   }
 
   const int64_t now_ms = _clock->TimeInMilliseconds();
   if (!decode_time_ms) {
     decode_time_ms =
         rtc::Optional<int32_t>(now_ms - frameInfo->decodeStartTimeMs);
   }
   _timing->StopDecodeTimer(decodedImage.timestamp(), *decode_time_ms, now_ms,
                            frameInfo->renderTimeMs);
 
+  // Report timing information.
+  if (frameInfo->timing.is_timing_frame) {
+    // Convert remote timestamps to local time from ntp timestamps.
+    frameInfo->timing.encode_start_ms -= ntp_offset_;
+    frameInfo->timing.encode_finish_ms -= ntp_offset_;
+    frameInfo->timing.packetization_finish_ms -= ntp_offset_;
+    frameInfo->timing.pacer_exit_ms -= ntp_offset_;
+    frameInfo->timing.network_timestamp_ms -= ntp_offset_;
+    frameInfo->timing.network2_timestamp_ms -= ntp_offset_;
+    // TODO(ilnik): Report timing information here.
+    // Capture time: decodedImage.ntp_time_ms() - ntp_offset
+    // Encode start: frameInfo->timing.encode_start_ms
+    // Encode finish: frameInfo->timing.encode_finish_ms
+    // Packetization done: frameInfo->timing.packetization_finish_ms
+    // Pacer exit: frameInfo->timing.pacer_exit_ms
+    // Network timestamp: frameInfo->timing.network_timestamp_ms
+    // Network2 timestamp: frameInfo->timing.network2_timestamp_ms
+    // Receive start: frameInfo->timing.receive_start_ms
+    // Receive finish: frameInfo->timing.receive_finish_ms
+    // Decode start: frameInfo->decodeStartTimeMs
+    // Decode finish: now_ms
+    // Render time: frameInfo->renderTimeMs
+  }
+
   decodedImage.set_timestamp_us(
       frameInfo->renderTimeMs * rtc::kNumMicrosecsPerMillisec);
   decodedImage.set_rotation(frameInfo->rotation);
   _receiveCallback->FrameToRender(decodedImage, qp, frameInfo->content_type);
 }
 
 int32_t VCMDecodedFrameCallback::ReceivedDecodedReferenceFrame(
     const uint64_t pictureId) {
   return _receiveCallback->ReceivedDecodedReferenceFrame(pictureId);
 }
@@ skipping 46 matching lines @@
 
   return _decoder->InitDecode(settings, numberOfCores);
 }
 
 int32_t VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, int64_t nowMs) {
     TRACE_EVENT1("webrtc", "VCMGenericDecoder::Decode", "timestamp",
                  frame.EncodedImage()._timeStamp);
     _frameInfos[_nextFrameInfoIdx].decodeStartTimeMs = nowMs;
     _frameInfos[_nextFrameInfoIdx].renderTimeMs = frame.RenderTimeMs();
     _frameInfos[_nextFrameInfoIdx].rotation = frame.rotation();
+    _frameInfos[_nextFrameInfoIdx].timing = frame.video_timing();
     // Set correctly only for key frames. Thus, use latest key frame
     // content type. If the corresponding key frame was lost, decode will fail
     // and content type will be ignored.
     if (frame.FrameType() == kVideoFrameKey) {
       _frameInfos[_nextFrameInfoIdx].content_type = frame.contentType();
       _last_keyframe_content_type = frame.contentType();
     } else {
       _frameInfos[_nextFrameInfoIdx].content_type = _last_keyframe_content_type;
     }
     _callback->Map(frame.TimeStamp(), &_frameInfos[_nextFrameInfoIdx]);
@@ skipping 30 matching lines @@
 
 bool VCMGenericDecoder::External() const {
   return _isExternal;
 }
 
 bool VCMGenericDecoder::PrefersLateDecoding() const {
   return _decoder->PrefersLateDecoding();
 }
 
 }  // namespace webrtc