Move Offset constants from VideoSendTiming value to VideoTimingExtension class

These constants describes how value should be put on the wire and thus
belong to the extension builder/writer class rather than extension value class

Bug: None
Change-Id: I65ca3923eddcc2e48563ad69b98356c159ad86be
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/166461
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30305}

api/video/video_timing.h

@@ -29,16 +29,6 @@ struct VideoSendTiming {
     kInvalid = std::numeric_limits<uint8_t>::max()  // Invalid, ignore!
   };
 
-  // Offsets of the fields in the RTP header extension, counting from the first
-  // byte after the one-byte header.
-  static constexpr uint8_t kFlagsOffset = 0;
-  static constexpr uint8_t kEncodeStartDeltaOffset = 1;
-  static constexpr uint8_t kEncodeFinishDeltaOffset = 3;
-  static constexpr uint8_t kPacketizationFinishDeltaOffset = 5;
-  static constexpr uint8_t kPacerExitDeltaOffset = 7;
-  static constexpr uint8_t kNetworkTimestampDeltaOffset = 9;
-  static constexpr uint8_t kNetwork2TimestampDeltaOffset = 11;
-
   // Returns |time_ms - base_ms| capped at max 16-bit value.
   // Used to fill this data structure as per
   // https://webrtc.org/experiments/rtp-hdrext/video-timing/ extension stores

modules/rtp_rtcp/source/rtp_header_extensions.cc

@@ -454,6 +454,13 @@ bool VideoContentTypeExtension::Write(rtc::ArrayView<uint8_t> data,
 constexpr RTPExtensionType VideoTimingExtension::kId;
 constexpr uint8_t VideoTimingExtension::kValueSizeBytes;
 constexpr const char VideoTimingExtension::kUri[];
+constexpr uint8_t VideoTimingExtension::kFlagsOffset;
+constexpr uint8_t VideoTimingExtension::kEncodeStartDeltaOffset;
+constexpr uint8_t VideoTimingExtension::kEncodeFinishDeltaOffset;
+constexpr uint8_t VideoTimingExtension::kPacketizationFinishDeltaOffset;
+constexpr uint8_t VideoTimingExtension::kPacerExitDeltaOffset;
+constexpr uint8_t VideoTimingExtension::kNetworkTimestampDeltaOffset;
+constexpr uint8_t VideoTimingExtension::kNetwork2TimestampDeltaOffset;
 
 bool VideoTimingExtension::Parse(rtc::ArrayView<const uint8_t> data,
                                  VideoSendTiming* timing) {
@@ -473,42 +480,38 @@ bool VideoTimingExtension::Parse(rtc::ArrayView<const uint8_t> data,
   }
 
   timing->encode_start_delta_ms = ByteReader<uint16_t>::ReadBigEndian(
-      data.data() + VideoSendTiming::kEncodeStartDeltaOffset - off);
+      data.data() + kEncodeStartDeltaOffset - off);
   timing->encode_finish_delta_ms = ByteReader<uint16_t>::ReadBigEndian(
-      data.data() + VideoSendTiming::kEncodeFinishDeltaOffset - off);
+      data.data() + kEncodeFinishDeltaOffset - off);
   timing->packetization_finish_delta_ms = ByteReader<uint16_t>::ReadBigEndian(
-      data.data() + VideoSendTiming::kPacketizationFinishDeltaOffset - off);
+      data.data() + kPacketizationFinishDeltaOffset - off);
   timing->pacer_exit_delta_ms = ByteReader<uint16_t>::ReadBigEndian(
-      data.data() + VideoSendTiming::kPacerExitDeltaOffset - off);
+      data.data() + kPacerExitDeltaOffset - off);
   timing->network_timestamp_delta_ms = ByteReader<uint16_t>::ReadBigEndian(
-      data.data() + VideoSendTiming::kNetworkTimestampDeltaOffset - off);
+      data.data() + kNetworkTimestampDeltaOffset - off);
   timing->network2_timestamp_delta_ms = ByteReader<uint16_t>::ReadBigEndian(
-      data.data() + VideoSendTiming::kNetwork2TimestampDeltaOffset - off);
+      data.data() + kNetwork2TimestampDeltaOffset - off);
   return true;
 }
 
 bool VideoTimingExtension::Write(rtc::ArrayView<uint8_t> data,
                                  const VideoSendTiming& timing) {
   RTC_DCHECK_EQ(data.size(), 1 + 2 * 6);
-  ByteWriter<uint8_t>::WriteBigEndian(
+  ByteWriter<uint8_t>::WriteBigEndian(data.data() + kFlagsOffset, timing.flags);
-      data.data() + VideoSendTiming::kFlagsOffset, timing.flags);
+  ByteWriter<uint16_t>::WriteBigEndian(data.data() + kEncodeStartDeltaOffset,
+                                       timing.encode_start_delta_ms);
+  ByteWriter<uint16_t>::WriteBigEndian(data.data() + kEncodeFinishDeltaOffset,
+                                       timing.encode_finish_delta_ms);
   ByteWriter<uint16_t>::WriteBigEndian(
-      data.data() + VideoSendTiming::kEncodeStartDeltaOffset,
+      data.data() + kPacketizationFinishDeltaOffset,
-      timing.encode_start_delta_ms);
-  ByteWriter<uint16_t>::WriteBigEndian(
-      data.data() + VideoSendTiming::kEncodeFinishDeltaOffset,
-      timing.encode_finish_delta_ms);
-  ByteWriter<uint16_t>::WriteBigEndian(
-      data.data() + VideoSendTiming::kPacketizationFinishDeltaOffset,
       timing.packetization_finish_delta_ms);
+  ByteWriter<uint16_t>::WriteBigEndian(data.data() + kPacerExitDeltaOffset,
+                                       timing.pacer_exit_delta_ms);
   ByteWriter<uint16_t>::WriteBigEndian(
-      data.data() + VideoSendTiming::kPacerExitDeltaOffset,
+      data.data() + kNetworkTimestampDeltaOffset,
-      timing.pacer_exit_delta_ms);
-  ByteWriter<uint16_t>::WriteBigEndian(
-      data.data() + VideoSendTiming::kNetworkTimestampDeltaOffset,
       timing.network_timestamp_delta_ms);
   ByteWriter<uint16_t>::WriteBigEndian(
-      data.data() + VideoSendTiming::kNetwork2TimestampDeltaOffset,
+      data.data() + kNetwork2TimestampDeltaOffset,
       timing.network2_timestamp_delta_ms);
   return true;
 }

modules/rtp_rtcp/source/rtp_header_extensions.h

@@ -192,6 +192,16 @@ class VideoTimingExtension {
   static constexpr const char kUri[] =
       "http://www.webrtc.org/experiments/rtp-hdrext/video-timing";
 
+  // Offsets of the fields in the RTP header extension, counting from the first
+  // byte after the one-byte header.
+  static constexpr uint8_t kFlagsOffset = 0;
+  static constexpr uint8_t kEncodeStartDeltaOffset = 1;
+  static constexpr uint8_t kEncodeFinishDeltaOffset = 3;
+  static constexpr uint8_t kPacketizationFinishDeltaOffset = 5;
+  static constexpr uint8_t kPacerExitDeltaOffset = 7;
+  static constexpr uint8_t kNetworkTimestampDeltaOffset = 9;
+  static constexpr uint8_t kNetwork2TimestampDeltaOffset = 11;
+
   static bool Parse(rtc::ArrayView<const uint8_t> data,
                     VideoSendTiming* timing);
   static size_t ValueSize(const VideoSendTiming&) { return kValueSizeBytes; }
@@ -204,7 +214,7 @@ class VideoTimingExtension {
   // Writes only single time delta to position idx.
   static bool Write(rtc::ArrayView<uint8_t> data,
                     uint16_t time_delta_ms,
-                    uint8_t idx);
+                    uint8_t offset);
 };
 
 class FrameMarkingExtension {

modules/rtp_rtcp/source/rtp_packet.cc

@@ -15,6 +15,7 @@
 #include <utility>
 
 #include "modules/rtp_rtcp/source/byte_io.h"
+#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
@@ -167,10 +168,12 @@ void RtpPacket::ZeroMutableExtensions() {
       case RTPExtensionType::kRtpExtensionVideoTiming: {
         // Nullify last entries, starting at pacer delay.
         // These are set by pacer and SFUs
-        if (VideoSendTiming::kPacerExitDeltaOffset < extension.length) {
+        if (VideoTimingExtension::kPacerExitDeltaOffset < extension.length) {
-          memset(WriteAt(extension.offset +
+          memset(
-                         VideoSendTiming::kPacerExitDeltaOffset),
+              WriteAt(extension.offset +
-                 0, extension.length - VideoSendTiming::kPacerExitDeltaOffset);
+                      VideoTimingExtension::kPacerExitDeltaOffset),
+              0,
+              extension.length - VideoTimingExtension::kPacerExitDeltaOffset);
         }
         break;
       }

modules/rtp_rtcp/source/rtp_packet_to_send.h

@@ -79,25 +79,25 @@ class RtpPacketToSend : public RtpPacket {
   void set_packetization_finish_time_ms(int64_t time) {
     SetExtension<VideoTimingExtension>(
         VideoSendTiming::GetDeltaCappedMs(capture_time_ms_, time),
-        VideoSendTiming::kPacketizationFinishDeltaOffset);
+        VideoTimingExtension::kPacketizationFinishDeltaOffset);
   }
 
   void set_pacer_exit_time_ms(int64_t time) {
     SetExtension<VideoTimingExtension>(
         VideoSendTiming::GetDeltaCappedMs(capture_time_ms_, time),
-        VideoSendTiming::kPacerExitDeltaOffset);
+        VideoTimingExtension::kPacerExitDeltaOffset);
   }
 
   void set_network_time_ms(int64_t time) {
     SetExtension<VideoTimingExtension>(
         VideoSendTiming::GetDeltaCappedMs(capture_time_ms_, time),
-        VideoSendTiming::kNetworkTimestampDeltaOffset);
+        VideoTimingExtension::kNetworkTimestampDeltaOffset);
   }
 
   void set_network2_time_ms(int64_t time) {
     SetExtension<VideoTimingExtension>(
         VideoSendTiming::GetDeltaCappedMs(capture_time_ms_, time),
-        VideoSendTiming::kNetwork2TimestampDeltaOffset);
+        VideoTimingExtension::kNetwork2TimestampDeltaOffset);
   }
 
  private: