Cast: Add capabity to parse receiver and sender log messages over RTCP.

media/cast/rtcp/rtcp_utility.cc

 // Copyright 2013 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/rtcp/rtcp_utility.h"
 
 #include "base/logging.h"
 #include "net/base/big_endian.h"
 
 namespace media {
@@ skipping 38 matching lines @@
       break;
     case kStateReportBlock:
       IterateReportBlockItem();
       break;
     case kStateSdes:
       IterateSdesItem();
       break;
     case kStateBye:
       IterateByeItem();
       break;
+    case kStateApplicationSpecificCastReceiverFrameLog:
+      IterateCastReceiverLogFrame();
+      break;
+    case kStateApplicationSpecificCastReceiverEventLog:
+      IterateCastReceiverLogEvent();
+      break;
+    case kStateApplicationSpecificCastSenderLog:
+      IterateCastSenderLog();
+      break;
     case kStateExtendedReportBlock:
       IterateExtendedReportItem();
       break;
     case kStateExtendedReportDelaySinceLastReceiverReport:
       IterateExtendedReportDelaySinceLastReceiverReportItem();
       break;
     case kStateGenericRtpFeedbackNack:
       IterateNackItem();
       break;
     case kStatePayloadSpecificRpsi:
@@ skipping 47 matching lines @@
           break;  // Nothing supported found, continue to next block!
         }
         return;
       case kPacketTypeBye:
         number_of_blocks_ = header.IC;
         if (!ParseBye()) {
           // Nothing supported found, continue to next block!
           break;
         }
         return;
+      case kPacketTypeApplicationDefined:
+        if (!ParseApplicationDefined(header.IC)) {
+          // Nothing supported found, continue to next block!
+          break;
+        }
+        return;
       case kPacketTypeGenericRtpFeedback:  // Fall through!
       case kPacketTypePayloadSpecific:
         if (!ParseFeedBackCommon(header)) {
           // Nothing supported found, continue to next block!
           break;
         }
         return;
       case kPacketTypeXr:
         if (!ParseExtendedReport()) {
           break;  // Nothing supported found, continue to next block!
@@ skipping 60 matching lines @@
 void RtcpParser::IteratePayloadSpecificCastItem() {
   bool success = ParsePayloadSpecificCastItem();
   if (!success) Iterate();
 }
 
 void RtcpParser::IteratePayloadSpecificCastNackItem() {
   bool success = ParsePayloadSpecificCastNackItem();
   if (!success) Iterate();
 }
 
+void RtcpParser::IterateCastReceiverLogFrame() {
+  bool success = ParseCastReceiverLogFrameItem();
+  if (!success) Iterate();
+}
+
+void RtcpParser::IterateCastReceiverLogEvent() {
+  bool success = ParseCastReceiverLogEventItem();
+  if (!success) Iterate();
+}
+
+void RtcpParser::IterateCastSenderLog() {
+  bool success = ParseCastSenderLogItem();
+  if (!success) Iterate();
+}
+
 void RtcpParser::Validate() {
   if (rtcp_data_ == NULL) return;  // NOT VALID
 
   RtcpCommonHeader header;
   bool success = RtcpParseCommonHeader(rtcp_data_begin_, rtcp_data_end_,
                                        &header);
 
   if (!success) return;  // NOT VALID!
 
   valid_packet_ = true;
@@ skipping 243 matching lines @@
   rtcp_data_ += 4;
 
   // We can have several CSRCs attached.
   if (length >= 4 * number_of_blocks_) {
     rtcp_data_ += (number_of_blocks_ - 1) * 4;
   }
   number_of_blocks_ = 0;
   return true;
 }
 
+bool RtcpParser::ParseApplicationDefined(uint8 subtype) {
+  ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
+  if (length < 16 ||
+      !(subtype == kSenderLogSubtype || subtype == kReceiverLogSubtype)) {
+    state_ = kStateTopLevel;
+    EndCurrentBlock();
+    return false;
+  }
+
+  uint32 sender_ssrc;
+  uint32 name;
+
+  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  big_endian_reader.Skip(4);  // Skip header.
+  big_endian_reader.ReadU32(&sender_ssrc);
+  big_endian_reader.ReadU32(&name);
+
+  if (name != kCast) {
+    state_ = kStateTopLevel;
+    EndCurrentBlock();
+    return false;
+  }
+  rtcp_data_ += 12;
+  switch (subtype) {
+    case kSenderLogSubtype:
+      state_ = kStateApplicationSpecificCastSenderLog;
+      field_type_ = kRtcpApplicationSpecificCastSenderLogCode;
+      field_.cast_sender_log.sender_ssrc = sender_ssrc;
+      break;
+    case kReceiverLogSubtype:
+      state_ = kStateApplicationSpecificCastReceiverFrameLog;
+      field_type_ = kRtcpApplicationSpecificCastReceiverLogCode;
+      field_.cast_receiver_log.sender_ssrc = sender_ssrc;
+      break;
+    default:
+      NOTREACHED();
+  }
+  return true;
+}
+
+bool RtcpParser::ParseCastReceiverLogFrameItem() {
+  ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
+  if (length < 12) {
+    state_ = kStateTopLevel;
+    EndCurrentBlock();
+    return false;
+  }
+  uint32 rtp_timestamp;
+  uint32 data;
+  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  big_endian_reader.ReadU32(&rtp_timestamp);
+  big_endian_reader.ReadU32(&data);
+
+  rtcp_data_ += 8;
+
+  field_.cast_receiver_log.rtp_timestamp = rtp_timestamp;
+  // We have 24 LSB of the event timestamp base on the wire.
+  field_.cast_receiver_log.event_timestamp_base = data & 0xffffff;
+
+  number_of_blocks_ = 1 + static_cast<uint8>(data >> 24);
+  state_ = kStateApplicationSpecificCastReceiverEventLog;
+  field_type_ = kRtcpApplicationSpecificCastReceiverLogFrameCode;
+  return true;
+}
+
+bool RtcpParser::ParseCastReceiverLogEventItem() {
+  ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
+  if (length < 4) {
+    state_ = kStateTopLevel;
+    EndCurrentBlock();
+    return false;
+  }
+  if (number_of_blocks_ == 0) {
+    // Continue parsing the next receiver frame event.
+    state_ = kStateApplicationSpecificCastReceiverFrameLog;
+    return false;
+  }
+  number_of_blocks_--;
+
+  uint16 delay_delta_or_packet_id;
+  uint16 event_type_and_timestamp_delta;
+  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  big_endian_reader.ReadU16(&delay_delta_or_packet_id);
+  big_endian_reader.ReadU16(&event_type_and_timestamp_delta);
+
+  rtcp_data_ += 4;
+
+  field_.cast_receiver_log.event =
+      static_cast<uint8>(event_type_and_timestamp_delta >> 12);
+  field_.cast_receiver_log.delay_delta_or_packet_id = delay_delta_or_packet_id;
+  field_.cast_receiver_log.event_timestamp_delta =
+      event_type_and_timestamp_delta & 0xfff;
+
+  field_type_ = kRtcpApplicationSpecificCastReceiverLogEventCode;
+  return true;
+}
+
+bool RtcpParser::ParseCastSenderLogItem() {
+  ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
+
+  if (length < 4) {
+    state_ = kStateTopLevel;
+    EndCurrentBlock();
+    return false;
+  }
+  uint32 data;
+  net::BigEndianReader big_endian_reader(rtcp_data_, length);
+  big_endian_reader.ReadU32(&data);
+
+  rtcp_data_ += 4;
+
+  field_.cast_sender_log.status = static_cast<uint8>(data >> 24);
+  // We have 24 LSB of the RTP timestamp on the wire.
+  field_.cast_sender_log.rtp_timestamp = data & 0xffffff;
+  field_type_ = kRtcpApplicationSpecificCastSenderLogCode;
+  return true;
+}
+
 bool RtcpParser::ParseFeedBackCommon(const RtcpCommonHeader& header) {
   DCHECK((header.PT == kPacketTypeGenericRtpFeedback) ||
          (header.PT == kPacketTypePayloadSpecific)) << "Invalid state";
 
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
 
   if (length < 12) {  // 4 * 3, RFC4585 section 6.1
     EndCurrentBlock();
     return false;
   }
@@ skipping 200 matching lines @@
   field_type_ = kRtcpPayloadSpecificRembItemCode;
 
   for (int i = 0; i < field_.remb_item.number_of_ssrcs; i++) {
     big_endian_reader.ReadU32(&field_.remb_item.ssrcs[i]);
   }
   return true;
 }
 
 bool RtcpParser::ParsePayloadSpecificCastItem() {
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
-
   if (length < 4) {
     state_ = kStateTopLevel;
     EndCurrentBlock();
     return false;
   }
   field_type_ = kRtcpPayloadSpecificCastCode;
 
   net::BigEndianReader big_endian_reader(rtcp_data_, length);
   big_endian_reader.ReadU8(&field_.cast_item.last_frame_id);
   big_endian_reader.ReadU8(&field_.cast_item.number_of_lost_fields);
@@ skipping 153 matching lines @@
 
   rtcp_data_ += 12;
 
   number_of_blocks_--;
   field_type_ = kRtcpXrDlrrCode;
   return true;
 }
 
 }  // namespace cast
 }  // namespace media