Implement timing frames.

webrtc/api/video/video_timing.h

+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#ifndef WEBRTC_API_VIDEO_VIDEO_TIMING_H_
+#define WEBRTC_API_VIDEO_VIDEO_TIMING_H_
+
+#include <stdint.h>
+#include <limits>
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+// Video timing timstamps in ms counted from capture_time_ms of a frame.
+struct VideoTiming {
+  static const uint8_t kEncodeStartDeltaIdx = 0;
+  static const uint8_t kEncodeFinishIdx = 1;
+  static const uint8_t kPacketizationFinishDeltaIdx = 2;
+  static const uint8_t kPacerExitDeltaIdx = 3;
+  static const uint8_t kNetworkTimestampDeltaIdx = 4;
+
+  static uint16_t GetDeltaMs(uint64_t base_ms, uint64_t time_ms) {
+    RTC_DCHECK_GE(time_ms, base_ms);
+    uint64_t delta = time_ms - base_ms;
+    if (delta > std::numeric_limits<uint16_t>::max())
+      delta = std::numeric_limits<uint16_t>::max();
+    return static_cast<uint16_t>(delta);
+  }

[sprang_webrtc, 2017/05/31 11:12:54]

I'm not sure this is the right place for this? Can it be placed near the call
site for function instead?

Also, you could probably simplify it to something like
return static_cast<uint16_t>(std::min(time_ms - base_ms,
std::numeric_limits<uint16_t>::max()));

And add a comment as to its purpose.

[ilnik, 2017/05/31 15:17:44]

It's called by "modules/rtp_rtcp/source/rtp_packet_to_send.cc" and
"video/payload_router.cc".

What do you suppose would be a better place for it? It's only used to fill this
data structure, so I am not sure, where to put it.

I have added the clarifying comment.

I tried to do it with std::min at first, but it requires additional cast to make
both arguments of min() the same type. Overall, it's longer and harder to read,
I like this version more.

[nisse-webrtc, 2017/06/02 12:10:47]

There's also rtc::SafeMin and rtc::SafeMax (added by kwiberg a few weeks ago).

[kwiberg-webrtc, 2017/06/02 12:37:12]

Yes---those will accept any two integer types, and either automatically choose a
suitable return type or statically verify that the return type you ask for is
suitable. See the docs in base/safe_minmax.h.

In this case, you should be able to replace lines 30-33 with

  return rtc::SafeMin<uint16_t>(time_ms - base_ms,
                                std::numeric_limits<uint16_t>::max());

The compiler will complain if it can't prove that the result will always fit in
an uint16_t.

(I'll announce these soon, but I'd like to land their buddy SafeClamp first, so
that I don't have to write more than one PSA.)

For the specific case of clamping to the limits of a built-in integer type,
however, there's also rtc::saturated_cast:

  return rtc::saturated_cast<uint16_t>(time_ms - base_ms);

That's probably what you should use here.

[ilnik, 2017/06/02 14:00:46]

Done.

+
+  uint16_t encode_start_ms_delta;
+  uint16_t encode_finish_ms_delta;
+  uint16_t packetization_finish_ms_delta;
+  uint16_t pacer_exit_ms_delta;
+  uint16_t network_timstamp_ms_delta;
+  bool is_timing_frame;
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_API_VIDEO_VIDEO_TIMING_H_