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

media/cast/rtcp/rtcp_utility.h

 // 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.
 
 #ifndef MEDIA_CAST_RTCP_RTCP_UTILITY_H_
 #define MEDIA_CAST_RTCP_RTCP_UTILITY_H_
 
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/rtcp/rtcp_defines.h"
 
 namespace media {
 namespace cast {
 
 static const int kRtcpRpsiDataSize = 30;
 
 // RFC 3550 page 44, including end null.
 static const size_t kRtcpCnameSize = 256;
 static const int kRtcpMaxNumberOfRembFeedbackSsrcs = 255;
 
 static const uint32 kRemb = ('R' << 24) + ('E' << 16) + ('M' << 8) + 'B';
 static const uint32 kCast = ('C' << 24) + ('A' << 16) + ('S' << 8) + 'T';
 
+static const uint8 kSenderLogSubtype = 1;
+static const uint8 kReceiverLogSubtype = 2;
+
+static const size_t kRtcpMaxReceiverLogMessages = 256;
+static const size_t kRtcpMaxNackFields = 253;
+static const size_t kRtcpMaxCastLossFields = 100;
+
 struct RtcpFieldReceiverReport {
   // RFC 3550.
   uint32 sender_ssrc;
   uint8 number_of_report_blocks;
 };
 
 struct RtcpFieldSenderReport {
   // RFC 3550.
   uint32 sender_ssrc;
   uint8  number_of_report_blocks;
@@ skipping 98 matching lines @@
   uint8 last_frame_id;
   uint8 number_of_lost_fields;
 };
 
 struct RtcpFieldPayloadSpecificCastNackItem {
   uint8 frame_id;
   uint16 packet_id;
   uint8 bitmask;
 };
 
+struct RtcpFieldApplicationSpecificCastReceiverLogItem {
+  uint32 sender_ssrc;
+  uint32 rtp_timestamp;
+  uint32 event_timestamp_base;
+  uint8 event;
+  uint16 delay_delta_or_packet_id;
+  uint16 event_timestamp_delta;
+};
+
+struct RtcpFieldApplicationSpecificCastSenderLogItem {
+  uint32 sender_ssrc;
+  uint8 status;
+  uint32 rtp_timestamp;
+};
+
 union RtcpField {
   RtcpFieldReceiverReport               receiver_report;
   RtcpFieldSenderReport                 sender_report;
   RtcpFieldReportBlockItem              report_block_item;
   RtcpFieldSdesCName                    c_name;
   RtcpFieldBye                          bye;
 
   RtcpFieldXr                           extended_report;
   RtcpFieldXrRrtr                       rrtr;
   RtcpFieldXrDlrr                       dlrr;
 
   RtcpFieldGenericRtpFeedbackNack       nack;
   RtcpFieldGenericRtpFeedbackNackItem   nack_item;
 
   RtcpFieldPayloadSpecificPli           pli;
   RtcpFieldPayloadSpecificRpsi          rpsi;
   RtcpFieldPayloadSpecificFir           fir;
   RtcpFieldPayloadSpecificFirItem       fir_item;
   RtcpFieldPayloadSpecificApplication   application_specific;
   RtcpFieldPayloadSpecificRembItem      remb_item;
   RtcpFieldPayloadSpecificCastItem      cast_item;
   RtcpFieldPayloadSpecificCastNackItem  cast_nack_item;
+
+  RtcpFieldApplicationSpecificCastReceiverLogItem cast_receiver_log;
+  RtcpFieldApplicationSpecificCastSenderLogItem cast_sender_log;
 };
 
 enum RtcpFieldTypes {
   kRtcpNotValidCode,
 
   // RFC 3550.
   kRtcpRrCode,
   kRtcpSrCode,
   kRtcpReportBlockItemCode,
 
   kRtcpSdesCode,
   kRtcpSdesChunkCode,
   kRtcpByeCode,
 
   // RFC 3611.
   kRtcpXrCode,
   kRtcpXrRrtrCode,
   kRtcpXrDlrrCode,
   kRtcpXrUnknownItemCode,
 
   // RFC 4585.
   kRtcpGenericRtpFeedbackNackCode,
   kRtcpGenericRtpFeedbackNackItemCode,
 
   kRtcpPayloadSpecificPliCode,
   kRtcpPayloadSpecificRpsiCode,
   kRtcpPayloadSpecificAppCode,
 
+  // Application specific.
   kRtcpPayloadSpecificRembCode,
   kRtcpPayloadSpecificRembItemCode,
   kRtcpPayloadSpecificCastCode,
   kRtcpPayloadSpecificCastNackItemCode,
+  kRtcpApplicationSpecificCastReceiverLogCode,
+  kRtcpApplicationSpecificCastReceiverLogFrameCode,
+  kRtcpApplicationSpecificCastReceiverLogEventCode,
+  kRtcpApplicationSpecificCastSenderLogCode,
 
   // RFC 5104.
   kRtcpPayloadSpecificFirCode,
   kRtcpPayloadSpecificFirItemCode,
 
   // RFC 6051.
   kRtcpGenericRtpFeedbackSrReqCode,
 };
 
 struct RtcpCommonHeader {
   uint8  V;   // Version.
   bool   P;   // Padding.
   uint8  IC;  // Item count / subtype.
   uint8  PT;  // Packet Type.
   uint16 length_in_octets;
 };
 
 enum RtcpPacketTypes {
   kPacketTypeLow = 194,  // SMPTE time-code mapping.
   kPacketTypeInterArrivalJitterReport = 195,
   kPacketTypeSenderReport = 200,
   kPacketTypeReceiverReport = 201,
-  kPacketTypeSdes= 202,
+  kPacketTypeSdes = 202,
   kPacketTypeBye = 203,
   kPacketTypeApplicationDefined = 204,
   kPacketTypeGenericRtpFeedback = 205,
-  kPacketTypePayloadSpecific  = 206,
+  kPacketTypePayloadSpecific = 206,
   kPacketTypeXr = 207,
   kPacketTypeHigh = 210,  // Port Mapping.
 };
 
 class RtcpParser {
  public:
   RtcpParser(const uint8* rtcp_data, size_t rtcp_length);
   ~RtcpParser();
 
   RtcpFieldTypes FieldType() const;
   const RtcpField& Field() const;
 
   bool IsValid() const;
 
   RtcpFieldTypes Begin();
   RtcpFieldTypes Iterate();
 
  private:
   enum ParseState {
     kStateTopLevel,     // Top level packet
     kStateReportBlock,  // Sender/Receiver report report blocks.
     kStateSdes,
     kStateBye,
+    kStateApplicationSpecificCastReceiverFrameLog,
+    kStateApplicationSpecificCastReceiverEventLog,
+    kStateApplicationSpecificCastSenderLog,
     kStateExtendedReportBlock,
     kStateExtendedReportDelaySinceLastReceiverReport,
     kStateGenericRtpFeedbackNack,
     kStatePayloadSpecificRpsi,
     kStatePayloadSpecificFir,
     kStatePayloadSpecificApplication,
     kStatePayloadSpecificRemb,      // Application specific Remb.
     kStatePayloadSpecificCast,      // Application specific Cast.
     kStatePayloadSpecificCastNack,  // Application specific Nack for Cast.
   };
 
   bool RtcpParseCommonHeader(const uint8* begin,
                              const uint8* end,
                              RtcpCommonHeader* parsed_header) const;
 
   void IterateTopLevel();
   void IterateReportBlockItem();
   void IterateSdesItem();
   void IterateByeItem();
+  void IterateCastReceiverLogFrame();
+  void IterateCastReceiverLogEvent();
+  void IterateCastSenderLog();
   void IterateExtendedReportItem();
   void IterateExtendedReportDelaySinceLastReceiverReportItem();
   void IterateNackItem();
   void IterateRpsiItem();
   void IterateFirItem();
   void IteratePayloadSpecificAppItem();
   void IteratePayloadSpecificRembItem();
   void IteratePayloadSpecificCastItem();
   void IteratePayloadSpecificCastNackItem();
 
   void Validate();
   void EndCurrentBlock();
 
   bool ParseRR();
   bool ParseSR();
   bool ParseReportBlockItem();
 
   bool ParseSdes();
   bool ParseSdesItem();
   bool ParseSdesTypes();
   bool ParseBye();
   bool ParseByeItem();
+  bool ParseApplicationDefined(uint8 subtype);
+  bool ParseCastReceiverLogFrameItem();
+  bool ParseCastReceiverLogEventItem();
+  bool ParseCastSenderLogItem();
 
   bool ParseExtendedReport();
   bool ParseExtendedReportItem();
   bool ParseExtendedReportReceiverReferenceTimeReport();
   bool ParseExtendedReportDelaySinceLastReceiverReport();
 
   bool ParseFeedBackCommon(const RtcpCommonHeader& header);
   bool ParseNackItem();
   bool ParseRpsiItem();
   bool ParseFirItem();
@@ skipping 15 matching lines @@
   RtcpFieldTypes field_type_;
   RtcpField field_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpParser);
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_RTCP_RTCP_UTILITY_H_