cast: Split Rtcp into two for sender and receiver

media/cast/net/rtcp/rtcp_utility.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/net/rtcp/rtcp_utility.h"
 
 #include <stdint.h>
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "media/cast/net/cast_transport_defines.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // January 1970, in NTP seconds.
 // Network Time Protocol (NTP), which is in seconds relative to 0h UTC on
 // 1 January 1900.
 const int64_t kUnixEpochInNtpSeconds = INT64_C(2208988800);
 
 // Magic fractional unit. Used to convert time (in microseconds) to/from
 // fractional NTP seconds.
 const double kMagicFractionalUnit = 4.294967296E3;
-}
+
+}  // namespace
 
 RtcpParser::RtcpParser(uint32_t local_ssrc, uint32_t remote_ssrc)
     : local_ssrc_(local_ssrc),
       remote_ssrc_(remote_ssrc),
       has_sender_report_(false),
       has_last_report_(false),
       has_cast_message_(false),
       has_receiver_reference_time_report_(false) {}
 
 RtcpParser::~RtcpParser() {}
@@ skipping 152 matching lines @@
   if (!reader->ReadU32(&sender_ssrc) ||
       !reader->ReadU32(&name))
     return false;
 
   if (sender_ssrc != remote_ssrc_)
     return true;
 
   if (name != kCast)
     return false;
 
-  switch (header.IC /* subtype */ ) {
+  switch (header.IC) {  // subtype
     case kReceiverLogSubtype:
       if (!ParseCastReceiverLogFrameItem(reader))
         return false;
       break;
   }
   return true;
 }
 
 bool RtcpParser::ParseCastReceiverLogFrameItem(
     base::BigEndianReader* reader) {
@@ skipping 136 matching lines @@
     }
   }
 
   return true;
 }
 
 bool RtcpParser::ParseExtendedReportReceiverReferenceTimeReport(
     base::BigEndianReader* reader,
     uint32_t remote_ssrc) {
   receiver_reference_time_report_.remote_ssrc = remote_ssrc;
-  if(!reader->ReadU32(&receiver_reference_time_report_.ntp_seconds) ||
-     !reader->ReadU32(&receiver_reference_time_report_.ntp_fraction))
+  if (!reader->ReadU32(&receiver_reference_time_report_.ntp_seconds) ||
+      !reader->ReadU32(&receiver_reference_time_report_.ntp_fraction))
     return false;
 
   has_receiver_reference_time_report_ = true;
   return true;
 }
 
 // Converts a log event type to an integer value.
 // NOTE: We have only allocated 4 bits to represent the type of event over the
 // wire. Therefore, this function can only return values from 0 to 15.
 uint8_t ConvertEventTypeToWireFormat(CastLoggingEvent event) {
@@ skipping 78 matching lines @@
   int64_t ntp_time_us =
       ntp_seconds * base::Time::kMicrosecondsPerSecond +
       static_cast<int64_t>(std::ceil(ntp_fractions / kMagicFractionalUnit));
 
   base::TimeDelta elapsed_since_unix_epoch = base::TimeDelta::FromMicroseconds(
       ntp_time_us -
       (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond));
   return base::TimeTicks::UnixEpoch() + elapsed_since_unix_epoch;
 }
 
+namespace {
+enum {
+  // Minimum number of bytes required to make a valid RTCP packet.
+  kMinLengthOfRtcp = 8,
+};
+}  // namespace
+
+bool IsRtcpPacket(const uint8_t* packet, size_t length) {
+  if (length < kMinLengthOfRtcp) {
+    LOG(ERROR) << "Invalid RTCP packet received.";
+    return false;
+  }
+
+  uint8_t packet_type = packet[1];
+  return packet_type >= kPacketTypeLow && packet_type <= kPacketTypeHigh;
+}
+
+uint32_t GetSsrcOfSender(const uint8_t* rtcp_buffer, size_t length) {
+  if (length < kMinLengthOfRtcp)
+    return 0;
+  uint32_t ssrc_of_sender;
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_buffer), length);
+  big_endian_reader.Skip(4);  // Skip header.
+  big_endian_reader.ReadU32(&ssrc_of_sender);
+  return ssrc_of_sender;
+}
+
 }  // namespace cast
 }  // namespace media