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

media/cast/rtcp/rtcp_receiver.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_receiver.h"
 
 #include "base/logging.h"
 #include "media/cast/rtcp/rtcp_utility.h"
 
+namespace {
+
+media::cast::CastLoggingEvent TranslateToLogEventFromWireFormat(uint8 event) {
+  switch (event) {
+    case 1:
+      return media::cast::kAckSent;
+    case 2:
+      return media::cast::kAudioPlayoutDelay;
+    case 3:
+      return media::cast::kAudioFrameDecoded;
+    case 4:
+      return media::cast::kVideoFrameDecoded;
+    case 5:
+      return media::cast::kVideoRenderDelay;
+    case 6:
+      return media::cast::kPacketReceived;
+    default:
+      // If the sender adds new log messages we will end up here until we add
+      // the new messages in the receiver.
+      VLOG(1) << "Unexpected log message received: " << static_cast<int>(event);
+      NOTREACHED();
+      return media::cast::kUnknown;
+  }
+}
+
+media::cast::RtcpSenderFrameStatus TranslateToFrameStatusFromWireFormat(
+    uint8 status) {
+  switch (status) {
+    case 0:
+      return media::cast::kRtcpSenderFrameStatusUnknown;
+    case 1:
+      return media::cast::kRtcpSenderFrameStatusDroppedByEncoder;
+    case 2:
+      return media::cast::kRtcpSenderFrameStatusDroppedByFlowControl;
+    case 3:
+      return media::cast::kRtcpSenderFrameStatusSentToNetwork;
+    default:
+      // If the sender adds new log messages we will end up here until we add
+      // the new messages in the receiver.
+      NOTREACHED();
+      VLOG(1) << "Unexpected status received: " << static_cast<int>(status);
+      return media::cast::kRtcpSenderFrameStatusUnknown;
+  }
+}
+
+}  // namespace
+
 namespace media {
 namespace cast {
 
 RtcpReceiver::RtcpReceiver(scoped_refptr<CastEnvironment> cast_environment,
                            RtcpSenderFeedback* sender_feedback,
                            RtcpReceiverFeedback* receiver_feedback,
                            RtcpRttFeedback* rtt_feedback,
                            uint32 local_ssrc)
     : ssrc_(local_ssrc),
       remote_ssrc_(0),
@@ skipping 40 matching lines @@
         break;
       case kRtcpPayloadSpecificRpsiCode:
         HandleRpsi(rtcp_parser);
         break;
       case kRtcpPayloadSpecificFirCode:
         HandleFIR(rtcp_parser);
         break;
       case kRtcpPayloadSpecificAppCode:
         HandlePayloadSpecificApp(rtcp_parser);
         break;
+      case kRtcpApplicationSpecificCastReceiverLogCode:
+        HandleApplicationSpecificCastReceiverLog(rtcp_parser);
+        break;
+      case kRtcpApplicationSpecificCastSenderLogCode:
+        HandleApplicationSpecificCastSenderLog(rtcp_parser);
+        break;
       case kRtcpPayloadSpecificRembCode:
       case kRtcpPayloadSpecificRembItemCode:
-        // Ignore this until we want to support interop with webrtc.
-        rtcp_parser->Iterate();
-        break;
       case kRtcpPayloadSpecificCastCode:
       case kRtcpPayloadSpecificCastNackItemCode:
-        rtcp_parser->Iterate();
-        break;
+      case kRtcpApplicationSpecificCastReceiverLogFrameCode:
+      case kRtcpApplicationSpecificCastReceiverLogEventCode:
       case kRtcpNotValidCode:
       case kRtcpReportBlockItemCode:
       case kRtcpSdesChunkCode:
       case kRtcpGenericRtpFeedbackNackItemCode:
       case kRtcpPayloadSpecificFirItemCode:
       case kRtcpXrRrtrCode:
       case kRtcpXrDlrrCode:
       case kRtcpXrUnknownItemCode:
         rtcp_parser->Iterate();
-        DCHECK(false) << "Invalid state";
+        NOTREACHED() << "Invalid state";
         break;
     }
     field_type = rtcp_parser->FieldType();
   }
 }
 
 void RtcpReceiver::HandleSenderReport(RtcpParser* rtcp_parser) {
   RtcpFieldTypes rtcp_field_type = rtcp_parser->FieldType();
   const RtcpField& rtcp_field = rtcp_parser->Field();
 
@@ skipping 146 matching lines @@
     rtt_feedback_->OnReceivedDelaySinceLastReport(
         rtcp_field.dlrr.receivers_ssrc,
         rtcp_field.dlrr.last_receiver_report,
         rtcp_field.dlrr.delay_last_receiver_report);
   }
 }
 
 void RtcpReceiver::HandleNACK(RtcpParser* rtcp_parser) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
   if (ssrc_ != rtcp_field.nack.media_ssrc) {
-    // Not to us.
-    rtcp_parser->Iterate();
+    RtcpFieldTypes field_type;
+    // Message not to us. Iterate until we have passed this message.
+    do {
+      field_type = rtcp_parser->Iterate();
+    } while (field_type == kRtcpGenericRtpFeedbackNackItemCode);
     return;
   }
   std::list<uint16> nackSequenceNumbers;
 
   RtcpFieldTypes field_type = rtcp_parser->Iterate();
   while (field_type == kRtcpGenericRtpFeedbackNackItemCode) {
     HandleNACKItem(&rtcp_field, &nackSequenceNumbers);
     field_type = rtcp_parser->Iterate();
   }
 }
@@ skipping 57 matching lines @@
   }
   rpsi_picture_id += (rtcp_field.rpsi.native_bit_string[bytes - 1] & 0x7f);
 
   VLOG(1) << "Cast RTCP received RPSI with picture_id " << rpsi_picture_id;
 }
 
 void RtcpReceiver::HandlePayloadSpecificApp(RtcpParser* rtcp_parser) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
   uint32 remote_ssrc = rtcp_field.application_specific.sender_ssrc;
   if (remote_ssrc_ != remote_ssrc) {
-    // Message not to us.
-    rtcp_parser->Iterate();
+    // Message not to us. Iterate until we have passed this message.
+    RtcpFieldTypes field_type;
+    do {
+      field_type = rtcp_parser->Iterate();
+    } while (field_type == kRtcpPayloadSpecificRembCode ||
+             field_type == kRtcpPayloadSpecificRembItemCode ||
+             field_type == kRtcpPayloadSpecificCastCode ||
+             field_type == kRtcpPayloadSpecificCastNackItemCode);
     return;
   }
 
   RtcpFieldTypes packet_type = rtcp_parser->Iterate();
   switch (packet_type) {
     case kRtcpPayloadSpecificRembCode:
       packet_type = rtcp_parser->Iterate();
       if (packet_type == kRtcpPayloadSpecificRembItemCode) {
         HandlePayloadSpecificRembItem(rtcp_parser);
         rtcp_parser->Iterate();
@@ skipping 16 matching lines @@
   for (int i = 0; i < rtcp_field.remb_item.number_of_ssrcs; ++i) {
     if (rtcp_field.remb_item.ssrcs[i] == ssrc_) {
       // Found matching ssrc.
       VLOG(1) << "Cast RTCP received REMB with received_bitrate "
               << rtcp_field.remb_item.bitrate;
       return;
     }
   }
 }
 
+void RtcpReceiver::HandleApplicationSpecificCastReceiverLog(
+    RtcpParser* rtcp_parser) {
+  const RtcpField& rtcp_field = rtcp_parser->Field();
+
+  uint32 remote_ssrc = rtcp_field.cast_receiver_log.sender_ssrc;
+  if (remote_ssrc_ != remote_ssrc) {
+    // Message not to us. Iterate until we have passed this message.
+    RtcpFieldTypes field_type;
+    do {
+      field_type = rtcp_parser->Iterate();
+    } while (field_type == kRtcpApplicationSpecificCastReceiverLogFrameCode ||
+             field_type == kRtcpApplicationSpecificCastReceiverLogEventCode);
+    return;
+  }
+  RtcpReceiverLogMessage receiver_log;
+  RtcpFieldTypes field_type = rtcp_parser->Iterate();
+  while (field_type == kRtcpApplicationSpecificCastReceiverLogFrameCode) {
+    RtcpReceiverFrameLogMessage frame_log(
+        rtcp_field.cast_receiver_log.rtp_timestamp);
+
+    field_type = rtcp_parser->Iterate();
+    while (field_type == kRtcpApplicationSpecificCastReceiverLogEventCode) {
+      HandleApplicationSpecificCastReceiverEventLog(rtcp_parser,
+          &frame_log.event_log_messages_);
+      field_type = rtcp_parser->Iterate();
+    }
+    receiver_log.push_back(frame_log);
+  }
+
+  if (receiver_feedback_ && !receiver_log.empty()) {
+    receiver_feedback_->OnReceivedReceiverLog(receiver_log);
+  }
+}
+
+void RtcpReceiver::HandleApplicationSpecificCastReceiverEventLog(
+    RtcpParser* rtcp_parser,
+    RtcpReceiverEventLogMessages* event_log_messages) {
+  const RtcpField& rtcp_field = rtcp_parser->Field();
+
+  RtcpReceiverEventLogMessage event_log;
+  event_log.type = TranslateToLogEventFromWireFormat(
+      rtcp_field.cast_receiver_log.event);
+  event_log.event_timestamp = base::TimeTicks() +
+      base::TimeDelta::FromMilliseconds(
+          rtcp_field.cast_receiver_log.event_timestamp_base +
+          rtcp_field.cast_receiver_log.event_timestamp_delta);
+  event_log.delay_delta = base::TimeDelta::FromMilliseconds(
+      rtcp_field.cast_receiver_log.delay_delta_or_packet_id);
+  event_log.packet_id =
+      rtcp_field.cast_receiver_log.delay_delta_or_packet_id;
+  event_log_messages->push_back(event_log);
+}
+
+void RtcpReceiver::HandleApplicationSpecificCastSenderLog(
+    RtcpParser* rtcp_parser) {
+  const RtcpField& rtcp_field = rtcp_parser->Field();
+  uint32 remote_ssrc = rtcp_field.cast_sender_log.sender_ssrc;
+
+  if (remote_ssrc_ != remote_ssrc) {
+    RtcpFieldTypes field_type;
+    // Message not to us. Iterate until we have passed this message.
+    do {
+      field_type = rtcp_parser->Iterate();
+    } while (field_type == kRtcpApplicationSpecificCastSenderLogCode);
+    return;
+  }
+  RtcpSenderLogMessage sender_log;
+
+  RtcpFieldTypes field_type = rtcp_parser->Iterate();
+  while (field_type == kRtcpApplicationSpecificCastSenderLogCode) {
+    const RtcpField& rtcp_field = rtcp_parser->Field();
+    RtcpSenderFrameLogMessage frame_log;
+    frame_log.frame_status =
+        TranslateToFrameStatusFromWireFormat(rtcp_field.cast_sender_log.status);
+    frame_log.rtp_timestamp = rtcp_field.cast_sender_log.rtp_timestamp;
+    sender_log.push_back(frame_log);
+    field_type = rtcp_parser->Iterate();
+  }
+  if (receiver_feedback_) {
+    receiver_feedback_->OnReceivedSenderLog(sender_log);
+  }
+}
+
 void RtcpReceiver::HandlePayloadSpecificCastItem(RtcpParser* rtcp_parser) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
-
   RtcpCastMessage cast_message(remote_ssrc_);
   cast_message.ack_frame_id_ = ack_frame_id_wrap_helper_.MapTo32bitsFrameId(
       rtcp_field.cast_item.last_frame_id);
 
   RtcpFieldTypes packet_type = rtcp_parser->Iterate();
   while (packet_type == kRtcpPayloadSpecificCastNackItemCode) {
     const RtcpField& rtcp_field = rtcp_parser->Field();
     HandlePayloadSpecificCastNackItem(
         &rtcp_field, &cast_message.missing_frames_and_packets_);
     packet_type = rtcp_parser->Iterate();
@@ skipping 50 matching lines @@
 
 void RtcpReceiver::HandleFIRItem(const RtcpField* rtcp_field) {
   // Is it our sender that is requested to generate a new keyframe.
   if (ssrc_ != rtcp_field->fir_item.ssrc) return;
 
   VLOG(1) << "Cast RTCP received FIR on our SSRC " << ssrc_;
 }
 
 }  // namespace cast
 }  // namespace media