Add Cast PLI support on sender side.

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>
 
@@ skipping 16 matching lines @@
 
 }  // 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_cst2_message_(false),
-      has_receiver_reference_time_report_(false) {}
+      has_receiver_reference_time_report_(false),
+      has_picture_loss_indicator_(false) {}
 
 RtcpParser::~RtcpParser() {}
 
 bool RtcpParser::Parse(base::BigEndianReader* reader) {
   // Reset.
   has_sender_report_ = false;
   sender_report_ = RtcpSenderInfo();
   has_last_report_ = false;
   receiver_log_.clear();
   has_cast_message_ = false;
   has_cst2_message_ = false;
   has_receiver_reference_time_report_ = false;
+  has_picture_loss_indicator_ = false;
 
   while (reader->remaining()) {
     RtcpCommonHeader header;
     if (!ParseCommonHeader(reader, &header))
       return false;
 
     base::StringPiece tmp;
     if (!reader->ReadPiece(&tmp, header.length_in_octets - 4))
       return false;
     base::BigEndianReader chunk(tmp.data(), tmp.size());
 
     switch (header.PT) {
       case kPacketTypeSenderReport:
         if (!ParseSR(&chunk, header))
           return false;
         break;
 
       case kPacketTypeReceiverReport:
         if (!ParseRR(&chunk, header))
           return false;
         break;
 
       case kPacketTypeApplicationDefined:
         if (!ParseApplicationDefined(&chunk, header))
           return false;
         break;
 
-      case kPacketTypePayloadSpecific:
+      case kPacketTypePayloadSpecific: {
         if (!ParseFeedbackCommon(&chunk, header))
           return false;
+        if (!ParsePli(&chunk, header))
+          return false;
         break;
+      }
 
       case kPacketTypeXr:
         if (!ParseExtendedReport(&chunk, header))
           return false;
         break;
     }
   }
   return true;
 }
 
@@ skipping 88 matching lines @@
 
   if (ssrc == local_ssrc_) {
     last_report_ = last_report;
     delay_since_last_report_ = delay;
     has_last_report_ = true;
   }
 
   return true;
 }
 
+bool RtcpParser::ParsePli(base::BigEndianReader* reader,
+                          const RtcpCommonHeader& header) {
+  if (header.IC != 1)
+    return true;
+
+  uint32_t receiver_ssrc, sender_ssrc;
+  if (!reader->ReadU32(&receiver_ssrc))
+    return false;
+
+  // Ignore this Rtcp if the receiver ssrc does not match.
+  if (receiver_ssrc != remote_ssrc_)
+    return true;
+
+  if (!reader->ReadU32(&sender_ssrc))
+    return false;
+
+  // Ignore this Rtcp if the sender ssrc does not match.
+  if (sender_ssrc != local_ssrc_)
+    return true;
+
+  has_picture_loss_indicator_ = true;
+  return true;
+}
+
 bool RtcpParser::ParseApplicationDefined(base::BigEndianReader* reader,
                                          const RtcpCommonHeader& header) {
   uint32_t sender_ssrc;
   uint32_t name;
   if (!reader->ReadU32(&sender_ssrc) ||
       !reader->ReadU32(&name))
     return false;
 
   if (sender_ssrc != remote_ssrc_)
     return true;
@@ skipping 75 matching lines @@
     return true;
 
   uint32_t name;
   if (!reader->ReadU32(&name))
     return false;
 
   if (name != kCast) {
     return true;
   }
 
-  cast_message_.media_ssrc = remote_ssrc;
+  cast_message_.remote_ssrc = remote_ssrc;
 
   uint8_t last_frame_id;
   uint8_t number_of_lost_fields;
   if (!reader->ReadU8(&last_frame_id) ||
       !reader->ReadU8(&number_of_lost_fields) ||
       !reader->ReadU16(&cast_message_.target_delay_ms))
     return false;
 
   // Please note, this frame_id is still only 8-bit!
   cast_message_.ack_frame_id = last_frame_id;
@@ skipping 208 matching lines @@
   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