Cast: Implemented relative RTP timestamp in EncodingEventSubscriber.

media/cast/logging/encoding_event_subscriber.cc

Index: media/cast/logging/encoding_event_subscriber.cc
diff --git a/media/cast/logging/encoding_event_subscriber.cc b/media/cast/logging/encoding_event_subscriber.cc
index 265e39d2be4c05d5a23540d586e33a247600feae..5262e4928ecb5270f7fe774687b8248a2563a361 100644
--- a/media/cast/logging/encoding_event_subscriber.cc
+++ b/media/cast/logging/encoding_event_subscriber.cc
@@ -20,8 +20,12 @@ namespace media {
 namespace cast {
 
 EncodingEventSubscriber::EncodingEventSubscriber(
-    EventMediaType event_media_type, size_t max_frames)
-    : event_media_type_(event_media_type), max_frames_(max_frames) {}
+    EventMediaType event_media_type,
+    size_t max_frames)
+    : event_media_type_(event_media_type),
+      max_frames_(max_frames),
+      seen_first_rtp_timestamp_(false),
+      first_rtp_timestamp_(0u) {}
 
 EncodingEventSubscriber::~EncodingEventSubscriber() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -32,16 +36,17 @@ void EncodingEventSubscriber::OnReceiveFrameEvent(
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (ShouldProcessEvent(frame_event.type)) {
-    FrameEventMap::iterator it =
-        frame_event_map_.find(frame_event.rtp_timestamp);
+    RtpTimestamp relative_rtp_timestamp =
+        GetRelativeRtpTimestamp(frame_event.rtp_timestamp);
+    FrameEventMap::iterator it = frame_event_map_.find(relative_rtp_timestamp);
     linked_ptr<AggregatedFrameEvent> event_proto;
 
     // Look up existing entry. If not found, create a new entry and add to map.
     if (it == frame_event_map_.end()) {
       event_proto.reset(new AggregatedFrameEvent);
-      event_proto->set_rtp_timestamp(frame_event.rtp_timestamp);
+      event_proto->set_rtp_timestamp(relative_rtp_timestamp);
       frame_event_map_.insert(
-          std::make_pair(frame_event.rtp_timestamp, event_proto));
+          std::make_pair(relative_rtp_timestamp, event_proto));
     } else {
       event_proto = it->second;
     }
@@ -69,17 +74,19 @@ void EncodingEventSubscriber::OnReceivePacketEvent(
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (ShouldProcessEvent(packet_event.type)) {
+    RtpTimestamp relative_rtp_timestamp =
+        GetRelativeRtpTimestamp(packet_event.rtp_timestamp);
     PacketEventMap::iterator it =
-        packet_event_map_.find(packet_event.rtp_timestamp);
+        packet_event_map_.find(relative_rtp_timestamp);
     linked_ptr<AggregatedPacketEvent> event_proto;
     BasePacketEvent* base_packet_event_proto = NULL;
 
     // Look up existing entry. If not found, create a new entry and add to map.
     if (it == packet_event_map_.end()) {
       event_proto.reset(new AggregatedPacketEvent);
-      event_proto->set_rtp_timestamp(packet_event.rtp_timestamp);
+      event_proto->set_rtp_timestamp(relative_rtp_timestamp);
       packet_event_map_.insert(
-          std::make_pair(packet_event.rtp_timestamp, event_proto));
+          std::make_pair(relative_rtp_timestamp, event_proto));
       base_packet_event_proto = event_proto->add_base_packet_event();
       base_packet_event_proto->set_packet_id(packet_event.packet_id);
     } else {
@@ -120,21 +127,18 @@ void EncodingEventSubscriber::OnReceiveGenericEvent(
   // Do nothing, there are no generic events we are interested in.
 }
 
-void EncodingEventSubscriber::GetFrameEventsAndReset(
-    FrameEventMap* frame_event_map) {
+void EncodingEventSubscriber::GetEventsAndReset(
+    FrameEventMap* frame_events,
+    PacketEventMap* packet_events,
+    RtpTimestamp* first_rtp_timestamp) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  frame_event_map->swap(frame_event_map_);
-  frame_event_map_.clear();
-}
 
-void EncodingEventSubscriber::GetPacketEventsAndReset(
-    PacketEventMap* packet_event_map) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  packet_event_map->swap(packet_event_map_);
-  packet_event_map_.clear();
+  frame_events->swap(frame_event_map_);
+  packet_events->swap(packet_event_map_);
+  *first_rtp_timestamp = first_rtp_timestamp_;
+  Reset();
 }
 
-
 bool EncodingEventSubscriber::ShouldProcessEvent(CastLoggingEvent event) {
   return GetEventMediaType(event) == event_media_type_;
 }
@@ -153,5 +157,22 @@ void EncodingEventSubscriber::TruncatePacketEventMapIfNeeded() {
     packet_event_map_.erase(packet_event_map_.begin());
 }
 
+RtpTimestamp EncodingEventSubscriber::GetRelativeRtpTimestamp(
+    RtpTimestamp rtp_timestamp) {
+  if (!seen_first_rtp_timestamp_) {
+    seen_first_rtp_timestamp_ = true;
+    first_rtp_timestamp_ = rtp_timestamp;
+  }
+
+  return rtp_timestamp - first_rtp_timestamp_;
+}
+
+void EncodingEventSubscriber::Reset() {
+  frame_event_map_.clear();
+  packet_event_map_.clear();
+  seen_first_rtp_timestamp_ = false;
+  first_rtp_timestamp_ = 0u;
+}
+
 }  // namespace cast
 }  // namespace media