src/media/cast/rtcp/rtcp_utility.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_CAST_RTCP_RTCP_UTILITY_H_
   6 #define MEDIA_CAST_RTCP_RTCP_UTILITY_H_
   7
   8 #include "media/cast/cast_config.h"
   9 #include "media/cast/cast_defines.h"
  10 #include "media/cast/rtcp/rtcp_defines.h"
  11
  12 namespace media {
  13 namespace cast {
  14
  15 static const int kRtcpRpsiDataSize = 30;
  16
  17 // RFC 3550 page 44, including end null.
  18 static const size_t kRtcpCnameSize = 256;
  19 static const int kRtcpMaxNumberOfRembFeedbackSsrcs = 255;
  20
  21 static const uint32 kRemb = ('R' << 24) + ('E' << 16) + ('M' << 8) + 'B';
  22 static const uint32 kCast = ('C' << 24) + ('A' << 16) + ('S' << 8) + 'T';
  23
  24 static const uint8 kSenderLogSubtype = 1;
  25 static const uint8 kReceiverLogSubtype = 2;
  26
  27 static const size_t kRtcpMaxReceiverLogMessages = 256;
  28 static const size_t kRtcpMaxNackFields = 253;
  29 static const size_t kRtcpMaxCastLossFields = 100;
  30
  31 struct RtcpFieldReceiverReport {
  32   // RFC 3550.
  33   uint32 sender_ssrc;
  34   uint8 number_of_report_blocks;
  35 };
  36
  37 struct RtcpFieldSenderReport {
  38   // RFC 3550.
  39   uint32 sender_ssrc;
  40   uint8 number_of_report_blocks;
  41   uint32 ntp_most_significant;
  42   uint32 ntp_least_significant;
  43   uint32 rtp_timestamp;
  44   uint32 sender_packet_count;
  45   uint32 sender_octet_count;
  46 };
  47
  48 struct RtcpFieldReportBlockItem {
  49   // RFC 3550.
  50   uint32 ssrc;
  51   uint8 fraction_lost;
  52   uint32 cumulative_number_of_packets_lost;
  53   uint32 extended_highest_sequence_number;
  54   uint32 jitter;
  55   uint32 last_sender_report;
  56   uint32 delay_last_sender_report;
  57 };
  58
  59 struct RtcpFieldSdesCName {
  60   // RFC 3550
  61   uint32 sender_ssrc;
  62   char name[kRtcpCnameSize];
  63 };
  64
  65 struct RtcpFieldBye {
  66   // RFC 3550.
  67   uint32 sender_ssrc;
  68 };
  69
  70 struct RtcpFieldGenericRtpFeedbackNack {
  71   // RFC 4585.
  72   uint32 sender_ssrc;
  73   uint32 media_ssrc;
  74 };
  75
  76 struct RtcpFieldGenericRtpFeedbackNackItem {
  77   // RFC 4585.
  78   uint16 packet_id;
  79   uint16 bitmask;
  80 };
  81
  82 struct RtcpFieldPayloadSpecificFir {
  83   // RFC 5104.
  84   uint32 sender_ssrc;
  85   uint32 media_ssrc;  // zero!
  86 };
  87
  88 struct RtcpFieldPayloadSpecificFirItem {
  89   // RFC 5104.
  90   uint32 ssrc;
  91   uint8 command_sequence_number;
  92 };
  93
  94 struct RtcpFieldPayloadSpecificPli {
  95   // RFC 4585.
  96   uint32 sender_ssrc;
  97   uint32 media_ssrc;
  98 };
  99
 100 struct RtcpFieldPayloadSpecificRpsi {
 101   // RFC 4585.
 102   uint32 sender_ssrc;
 103   uint32 media_ssrc;
 104   uint8 payload_type;
 105   uint16 number_of_valid_bits;
 106   uint8 native_bit_string[kRtcpRpsiDataSize];
 107 };
 108
 109 struct RtcpFieldXr {
 110   // RFC 3611.
 111   uint32 sender_ssrc;
 112 };
 113
 114 struct RtcpFieldXrRrtr {
 115   // RFC 3611.
 116   uint32 ntp_most_significant;
 117   uint32 ntp_least_significant;
 118 };
 119
 120 struct RtcpFieldXrDlrr {
 121   // RFC 3611.
 122   uint32 receivers_ssrc;
 123   uint32 last_receiver_report;
 124   uint32 delay_last_receiver_report;
 125 };
 126
 127 struct RtcpFieldPayloadSpecificApplication {
 128   uint32 sender_ssrc;
 129   uint32 media_ssrc;
 130 };
 131
 132 struct RtcpFieldPayloadSpecificRembItem {
 133   uint32 bitrate;
 134   uint8 number_of_ssrcs;
 135   uint32 ssrcs[kRtcpMaxNumberOfRembFeedbackSsrcs];
 136 };
 137
 138 struct RtcpFieldPayloadSpecificCastItem {
 139   uint8 last_frame_id;
 140   uint8 number_of_lost_fields;
 141   uint16 target_delay_ms;
 142 };
 143
 144 struct RtcpFieldPayloadSpecificCastNackItem {
 145   uint8 frame_id;
 146   uint16 packet_id;
 147   uint8 bitmask;
 148 };
 149
 150 struct RtcpFieldApplicationSpecificCastReceiverLogItem {
 151   uint32 sender_ssrc;
 152   uint32 rtp_timestamp;
 153   uint32 event_timestamp_base;
 154   uint8 event;
 155   uint16 delay_delta_or_packet_id;
 156   uint16 event_timestamp_delta;
 157 };
 158
 159 struct RtcpFieldApplicationSpecificCastSenderLogItem {
 160   uint32 sender_ssrc;
 161   uint8 status;
 162   uint32 rtp_timestamp;
 163 };
 164
 165 union RtcpField {
 166   RtcpFieldReceiverReport receiver_report;
 167   RtcpFieldSenderReport sender_report;
 168   RtcpFieldReportBlockItem report_block_item;
 169   RtcpFieldSdesCName c_name;
 170   RtcpFieldBye bye;
 171
 172   RtcpFieldXr extended_report;
 173   RtcpFieldXrRrtr rrtr;
 174   RtcpFieldXrDlrr dlrr;
 175
 176   RtcpFieldGenericRtpFeedbackNack nack;
 177   RtcpFieldGenericRtpFeedbackNackItem nack_item;
 178
 179   RtcpFieldPayloadSpecificPli pli;
 180   RtcpFieldPayloadSpecificRpsi rpsi;
 181   RtcpFieldPayloadSpecificFir fir;
 182   RtcpFieldPayloadSpecificFirItem fir_item;
 183   RtcpFieldPayloadSpecificApplication application_specific;
 184   RtcpFieldPayloadSpecificRembItem remb_item;
 185   RtcpFieldPayloadSpecificCastItem cast_item;
 186   RtcpFieldPayloadSpecificCastNackItem cast_nack_item;
 187
 188   RtcpFieldApplicationSpecificCastReceiverLogItem cast_receiver_log;
 189   RtcpFieldApplicationSpecificCastSenderLogItem cast_sender_log;
 190 };
 191
 192 enum RtcpFieldTypes {
 193   kRtcpNotValidCode,
 194
 195   // RFC 3550.
 196   kRtcpRrCode,
 197   kRtcpSrCode,
 198   kRtcpReportBlockItemCode,
 199   kRtcpSdesCode,
 200   kRtcpSdesChunkCode,
 201   kRtcpByeCode,
 202
 203   // RFC 3611.
 204   kRtcpXrCode,
 205   kRtcpXrRrtrCode,
 206   kRtcpXrDlrrCode,
 207   kRtcpXrUnknownItemCode,
 208
 209   // RFC 4585.
 210   kRtcpGenericRtpFeedbackNackCode,
 211   kRtcpGenericRtpFeedbackNackItemCode,
 212   kRtcpPayloadSpecificPliCode,
 213   kRtcpPayloadSpecificRpsiCode,
 214   kRtcpPayloadSpecificAppCode,
 215
 216   // Application specific.
 217   kRtcpPayloadSpecificRembCode,
 218   kRtcpPayloadSpecificRembItemCode,
 219   kRtcpPayloadSpecificCastCode,
 220   kRtcpPayloadSpecificCastNackItemCode,
 221   kRtcpApplicationSpecificCastReceiverLogCode,
 222   kRtcpApplicationSpecificCastReceiverLogFrameCode,
 223   kRtcpApplicationSpecificCastReceiverLogEventCode,
 224   kRtcpApplicationSpecificCastSenderLogCode,
 225
 226   // RFC 5104.
 227   kRtcpPayloadSpecificFirCode,
 228   kRtcpPayloadSpecificFirItemCode,
 229
 230   // RFC 6051.
 231   kRtcpGenericRtpFeedbackSrReqCode,
 232 };
 233
 234 struct RtcpCommonHeader {
 235   uint8 V;   // Version.
 236   bool P;    // Padding.
 237   uint8 IC;  // Item count / subtype.
 238   uint8 PT;  // Packet Type.
 239   uint16 length_in_octets;
 240 };
 241
 242 class RtcpParser {
 243  public:
 244   RtcpParser(const uint8* rtcp_data, size_t rtcp_length);
 245   ~RtcpParser();
 246
 247   RtcpFieldTypes FieldType() const;
 248   const RtcpField& Field() const;
 249
 250   bool IsValid() const;
 251
 252   RtcpFieldTypes Begin();
 253   RtcpFieldTypes Iterate();
 254
 255  private:
 256   enum ParseState {
 257     kStateTopLevel,     // Top level packet
 258     kStateReportBlock,  // Sender/Receiver report report blocks.
 259     kStateSdes,
 260     kStateBye,
 261     kStateApplicationSpecificCastReceiverFrameLog,
 262     kStateApplicationSpecificCastReceiverEventLog,
 263     kStateApplicationSpecificCastSenderLog,
 264     kStateExtendedReportBlock,
 265     kStateExtendedReportDelaySinceLastReceiverReport,
 266     kStateGenericRtpFeedbackNack,
 267     kStatePayloadSpecificRpsi,
 268     kStatePayloadSpecificFir,
 269     kStatePayloadSpecificApplication,
 270     kStatePayloadSpecificRemb,      // Application specific Remb.
 271     kStatePayloadSpecificCast,      // Application specific Cast.
 272     kStatePayloadSpecificCastNack,  // Application specific Nack for Cast.
 273   };
 274
 275   bool RtcpParseCommonHeader(const uint8* begin,
 276                              const uint8* end,
 277                              RtcpCommonHeader* parsed_header) const;
 278
 279   void IterateTopLevel();
 280   void IterateReportBlockItem();
 281   void IterateSdesItem();
 282   void IterateByeItem();
 283   void IterateCastReceiverLogFrame();
 284   void IterateCastReceiverLogEvent();
 285   void IterateCastSenderLog();
 286   void IterateExtendedReportItem();
 287   void IterateExtendedReportDelaySinceLastReceiverReportItem();
 288   void IterateNackItem();
 289   void IterateRpsiItem();
 290   void IterateFirItem();
 291   void IteratePayloadSpecificAppItem();
 292   void IteratePayloadSpecificRembItem();
 293   void IteratePayloadSpecificCastItem();
 294   void IteratePayloadSpecificCastNackItem();
 295
 296   void Validate();
 297   void EndCurrentBlock();
 298
 299   bool ParseRR();
 300   bool ParseSR();
 301   bool ParseReportBlockItem();
 302
 303   bool ParseSdes();
 304   bool ParseSdesItem();
 305   bool ParseSdesTypes();
 306   bool ParseBye();
 307   bool ParseByeItem();
 308   bool ParseApplicationDefined(uint8 subtype);
 309   bool ParseCastReceiverLogFrameItem();
 310   bool ParseCastReceiverLogEventItem();
 311   bool ParseCastSenderLogItem();
 312
 313   bool ParseExtendedReport();
 314   bool ParseExtendedReportItem();
 315   bool ParseExtendedReportReceiverReferenceTimeReport();
 316   bool ParseExtendedReportDelaySinceLastReceiverReport();
 317
 318   bool ParseFeedBackCommon(const RtcpCommonHeader& header);
 319   bool ParseNackItem();
 320   bool ParseRpsiItem();
 321   bool ParseFirItem();
 322   bool ParsePayloadSpecificAppItem();
 323   bool ParsePayloadSpecificRembItem();
 324   bool ParsePayloadSpecificCastItem();
 325   bool ParsePayloadSpecificCastNackItem();
 326
 327  private:
 328   const uint8* const rtcp_data_begin_;
 329   const uint8* const rtcp_data_end_;
 330
 331   bool valid_packet_;
 332   const uint8* rtcp_data_;
 333   const uint8* rtcp_block_end_;
 334
 335   ParseState state_;
 336   uint8 number_of_blocks_;
 337   RtcpFieldTypes field_type_;
 338   RtcpField field_;
 339
 340   DISALLOW_COPY_AND_ASSIGN(RtcpParser);
 341 };
 342
 343 }  // namespace cast
 344 }  // namespace media
 345
 346 #endif  // MEDIA_CAST_RTCP_RTCP_UTILITY_H_