Cast: Limit number of events/packets in EncodingEventSubscriber protos.

media/cast/logging/log_deserializer.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/logging/log_deserializer.h"
 
 #include <map>
 #include <utility>
 
 #include "base/big_endian.h"
+#include "base/memory/scoped_ptr.h"
 #include "third_party/zlib/zlib.h"
 
 using media::cast::FrameEventMap;
 using media::cast::PacketEventMap;
 using media::cast::RtpTimestamp;
 using media::cast::proto::AggregatedFrameEvent;
 using media::cast::proto::AggregatedPacketEvent;
+using media::cast::proto::BasePacketEvent;
 using media::cast::proto::LogMetadata;
 
 namespace {
 
 // Use 60MB of temp buffer to hold uncompressed data if |compress| is true.
 // This is double the size of temp buffer used during compression (30MB)
 // since the there are two streams in the blob.
 // Keep in sync with media/cast/logging/log_serializer.cc.
 const int kMaxUncompressedBytes = 60 * 1000 * 1000;
 
+void MergePacketEvent(const AggregatedPacketEvent& from,
+    linked_ptr<AggregatedPacketEvent> to) {
+  for (int i = 0; i < from.base_packet_event_size(); i++) {
+    const BasePacketEvent& from_base_event = from.base_packet_event(i);
+    bool merged = false;
+    for (int j = 0; j < to->base_packet_event_size(); j++) {
+      BasePacketEvent* to_base_event = to->mutable_base_packet_event(i);
+      if (from_base_event.packet_id() == to_base_event->packet_id()) {
+        to_base_event->MergeFrom(from_base_event);
+        merged = true;
+        break;
+      }
+    }
+    if (!merged) {
+      BasePacketEvent* to_base_event = to->add_base_packet_event();
+      to_base_event->CopyFrom(from_base_event);
+    }
+  }
+}
+
+void MergeFrameEvent(const AggregatedFrameEvent& from,
+    linked_ptr<AggregatedFrameEvent> to) {
+  to->mutable_event_type()->MergeFrom(from.event_type());
+  to->mutable_event_timestamp_ms()->MergeFrom(from.event_timestamp_ms());
+  if (!to->has_encoded_frame_size())
+    to->set_encoded_frame_size(from.encoded_frame_size());
+  if (!to->has_delay_millis())
+    to->set_delay_millis(from.delay_millis());
+  if (!to->has_key_frame())
+    to->set_key_frame(from.key_frame());
+}
+
 bool PopulateDeserializedLog(base::BigEndianReader* reader,
                              media::cast::DeserializedLog* log) {
   FrameEventMap frame_event_map;
   PacketEventMap packet_event_map;
 
   int num_frame_events = log->metadata.num_frame_events();
   RtpTimestamp relative_rtp_timestamp = 0;
   uint16 proto_size = 0;
   for (int i = 0; i < num_frame_events; i++) {
     if (!reader->ReadU16(&proto_size))
       return false;
 
     linked_ptr<AggregatedFrameEvent> frame_event(new AggregatedFrameEvent);
     if (!frame_event->ParseFromArray(reader->ptr(), proto_size))
       return false;
     if (!reader->Skip(proto_size))
       return false;
 
     // During serialization the RTP timestamp in proto is relative to previous
     // frame.
     // Adjust RTP timestamp back to value relative to first RTP timestamp.
     frame_event->set_relative_rtp_timestamp(
         frame_event->relative_rtp_timestamp() + relative_rtp_timestamp);
     relative_rtp_timestamp = frame_event->relative_rtp_timestamp();
 
-    std::pair<FrameEventMap::iterator, bool> result = frame_event_map.insert(
-        std::make_pair(frame_event->relative_rtp_timestamp(), frame_event));
-    if (!result.second) {
-      VLOG(1) << "Duplicate frame event entry detected: "
-              << frame_event->relative_rtp_timestamp();
-      return false;
+    FrameEventMap::iterator it = frame_event_map.find(
+        frame_event->relative_rtp_timestamp());
+    if (it == frame_event_map.end()) {
+      frame_event_map.insert(
+          std::make_pair(frame_event->relative_rtp_timestamp(), frame_event));
+    } else {
+      // Events for the same frame might have been split into more than one
+      // proto. Merge them.
+      MergeFrameEvent(*frame_event, it->second);
     }
   }
 
   log->frame_events.swap(frame_event_map);
 
   int num_packet_events = log->metadata.num_packet_events();
   relative_rtp_timestamp = 0;
   for (int i = 0; i < num_packet_events; i++) {
     if (!reader->ReadU16(&proto_size))
       return false;
 
     linked_ptr<AggregatedPacketEvent> packet_event(new AggregatedPacketEvent);
     if (!packet_event->ParseFromArray(reader->ptr(), proto_size))
       return false;
     if (!reader->Skip(proto_size))
       return false;
 
     packet_event->set_relative_rtp_timestamp(
         packet_event->relative_rtp_timestamp() + relative_rtp_timestamp);
     relative_rtp_timestamp = packet_event->relative_rtp_timestamp();
 
-    std::pair<PacketEventMap::iterator, bool> result = packet_event_map.insert(
-        std::make_pair(packet_event->relative_rtp_timestamp(), packet_event));
-    if (!result.second) {
-      VLOG(1) << "Duplicate packet event entry detected: "
-              << packet_event->relative_rtp_timestamp();
-      return false;
+    PacketEventMap::iterator it = packet_event_map.find(
+        packet_event->relative_rtp_timestamp());
+    if (it == packet_event_map.end()) {
+      packet_event_map.insert(
+          std::make_pair(packet_event->relative_rtp_timestamp(), packet_event));
+    } else {
+      // Events for the same frame might have been split into more than one
+      // proto. Merge them.
+      MergePacketEvent(*packet_event, it->second);
     }
   }
 
   log->packet_events.swap(packet_event_map);
 
   return true;
 }
 
 bool DoDeserializeEvents(const char* data,
                          int data_bytes,
@@ skipping 100 matching lines @@
   } else {
     return DoDeserializeEvents(data, data_bytes, audio_log, video_log);
   }
 }
 
 DeserializedLog::DeserializedLog() {}
 DeserializedLog::~DeserializedLog() {}
 
 }  // namespace cast
 }  // namespace media