Cast: Add capabity to send Receiver and Sender log messages over RTCP.

media/cast/rtcp/rtcp_sender.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_sender.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "media/cast/pacing/paced_sender.h"
 #include "media/cast/rtcp/rtcp_utility.h"
 #include "net/base/big_endian.h"
 
+static const size_t kRtcpCastLogHeaderSize = 12;
+static const size_t kRtcpSenderFrameLogSize = 4;
+static const size_t kRtcpReceiverFrameLogSize = 8;
+static const size_t kRtcpReceiverEventLogSize = 4;
+
+namespace {
+uint16 MergeEventTypeAndTimestampForWireFormat(
+    const media::cast::CastLoggingEvent& event,
+    const base::TimeDelta& time_delta) {
+  int64 time_delta_ms = time_delta.InMilliseconds();
+  // Max delta is 4096 milliseconds.
+  DCHECK_GE(GG_INT64_C(0xfff), time_delta_ms);
+
+  uint16 event_type_and_timestamp_delta =
+      static_cast<uint16>(time_delta_ms & 0xfff);
+
+  uint16 event_type = 0;
+  switch (event) {
+    case media::cast::kAckSent:
+      event_type = 1;
+      break;
+    case media::cast::kAudioPlayoutDelay:
+      event_type = 2;
+      break;
+    case media::cast::kAudioFrameDecoded:
+      event_type = 3;
+      break;
+    case media::cast::kVideoFrameDecoded:
+      event_type = 4;
+      break;
+    case media::cast::kVideoRenderDelay:
+      event_type = 5;
+      break;
+    case media::cast::kPacketReceived:
+      event_type = 6;
+      break;
+    default:
+      NOTREACHED();
+  }
+  DCHECK(!(event_type & 0xfff0));
+  return (event_type << 12) + event_type_and_timestamp_delta;
+}
+
+bool ScanRtcpReceiverLogMessage(
+    const media::cast::RtcpReceiverLogMessage& receiver_log_message,
+    size_t start_size,
+    size_t* number_of_frames,
+    size_t* total_number_of_messages_to_send,
+    size_t* rtcp_log_size) {
+  if (receiver_log_message.empty()) return false;
+
+  size_t remaining_space = media::cast::kIpPacketSize - start_size;
+
+  // We must have space for at least one message
+  DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize +
+      kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize)
+      << "Not enough buffer space";
+
+  if (remaining_space < kRtcpCastLogHeaderSize + kRtcpReceiverFrameLogSize +
+      kRtcpReceiverEventLogSize) {
+    return false;
+  }
+  // Account for the RTCP header for an application-defined packet.
+  remaining_space -= kRtcpCastLogHeaderSize;
+
+  media::cast::RtcpReceiverLogMessage::const_iterator frame_it =
+      receiver_log_message.begin();
+  for (; frame_it != receiver_log_message.end(); ++frame_it) {
+    (*number_of_frames)++;
+    remaining_space -= kRtcpReceiverFrameLogSize;
+
+    size_t messages_in_frame = frame_it->event_log_messages.size();
+    size_t remaining_space_in_messages =
+        remaining_space / kRtcpReceiverEventLogSize;
+    size_t messages_to_send = std::min(messages_in_frame,
+                                       remaining_space_in_messages);
+    if (messages_to_send > media::cast::kRtcpMaxReceiverLogMessages) {
+      // We can't send more than 256 messages.
+      remaining_space -= media::cast::kRtcpMaxReceiverLogMessages *
+          kRtcpReceiverEventLogSize;
+      *total_number_of_messages_to_send +=
+          media::cast::kRtcpMaxReceiverLogMessages;
+      break;
+    }
+    remaining_space -= messages_to_send * kRtcpReceiverEventLogSize;
+    *total_number_of_messages_to_send += messages_to_send;
+
+    if (remaining_space <
+        kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize) {
+      // Make sure that we have room for at least one more message.
+      break;
+    }
+  }
+  *rtcp_log_size = kRtcpCastLogHeaderSize +
+      *number_of_frames * kRtcpReceiverFrameLogSize +
+      *total_number_of_messages_to_send * kRtcpReceiverEventLogSize;
+  DCHECK_GE(media::cast::kIpPacketSize,
+            start_size + *rtcp_log_size) << "Not enough buffer space";
+
+  VLOG(1) << "number of frames " << *number_of_frames;
+  VLOG(1) << "total messages to send " << *total_number_of_messages_to_send;
+  VLOG(1) << "rtcp log size " << *rtcp_log_size;
+  return true;
+}
+}  // namespace
+
 namespace media {
 namespace cast {
 
-static const size_t kRtcpMaxNackFields = 253;
-static const size_t kRtcpMaxCastLossFields = 100;
-
 RtcpSender::RtcpSender(PacedPacketSender* outgoing_transport,
                        uint32 sending_ssrc,
                        const std::string& c_name)
      : ssrc_(sending_ssrc),
        c_name_(c_name),
        transport_(outgoing_transport) {
   DCHECK_LT(c_name_.length(), kRtcpCnameSize) << "Invalid config";
 }
 
 RtcpSender::~RtcpSender() {}
 
 void RtcpSender::SendRtcpFromRtpSender(uint32 packet_type_flags,
                                        const RtcpSenderInfo* sender_info,
                                        const RtcpDlrrReportBlock* dlrr,
-                                       const RtcpSenderLogMessage* sender_log) {
+                                       RtcpSenderLogMessage* sender_log) {
   if (packet_type_flags & kRtcpRr ||
       packet_type_flags & kRtcpPli ||
       packet_type_flags & kRtcpRrtr ||
       packet_type_flags & kRtcpCast ||
       packet_type_flags & kRtcpReceiverLog ||
       packet_type_flags & kRtcpRpsi ||
       packet_type_flags & kRtcpRemb ||
       packet_type_flags & kRtcpNack) {
     NOTREACHED() << "Invalid argument";
   }
@@ skipping 20 matching lines @@
     return;  // Sanity don't send empty packets.
 
   transport_->SendRtcpPacket(packet);
 }
 
 void RtcpSender::SendRtcpFromRtpReceiver(
     uint32 packet_type_flags,
     const RtcpReportBlock* report_block,
     const RtcpReceiverReferenceTimeReport* rrtr,
     const RtcpCastMessage* cast_message,
-    const RtcpReceiverLogMessage* receiver_log) {
+    RtcpReceiverLogMessage* receiver_log) {
   if (packet_type_flags & kRtcpSr ||
       packet_type_flags & kRtcpDlrr ||
       packet_type_flags & kRtcpSenderLog) {
     NOTREACHED() << "Invalid argument";
   }
   if (packet_type_flags & kRtcpPli ||
       packet_type_flags & kRtcpRpsi ||
       packet_type_flags & kRtcpRemb ||
       packet_type_flags & kRtcpNack) {
     // Implement these for webrtc interop.
@@ skipping 34 matching lines @@
   // Sender report.
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 52, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 52 > kIpPacketSize) return;
 
   uint16 number_of_rows = (report_block) ? 12 : 6;
   packet->resize(start_size + 28);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28);
   big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
-  big_endian_writer.WriteU8(200);
+  big_endian_writer.WriteU8(kPacketTypeSenderReport);
   big_endian_writer.WriteU16(number_of_rows);
   big_endian_writer.WriteU32(ssrc_);
   big_endian_writer.WriteU32(sender_info.ntp_seconds);
   big_endian_writer.WriteU32(sender_info.ntp_fraction);
   big_endian_writer.WriteU32(sender_info.rtp_timestamp);
   big_endian_writer.WriteU32(sender_info.send_packet_count);
   big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
 
   if (report_block) {
     AddReportBlocks(*report_block, packet);  // Adds 24 bytes.
   }
 }
 
 void RtcpSender::BuildRR(const RtcpReportBlock* report_block,
                          std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 32, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 32 > kIpPacketSize) return;
 
   uint16 number_of_rows = (report_block) ? 7 : 1;
   packet->resize(start_size + 8);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
   big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
-  big_endian_writer.WriteU8(201);
+  big_endian_writer.WriteU8(kPacketTypeReceiverReport);
   big_endian_writer.WriteU16(number_of_rows);
   big_endian_writer.WriteU32(ssrc_);
 
   if (report_block) {
     AddReportBlocks(*report_block, packet);  // Adds 24 bytes.
   }
 }
 
 void RtcpSender::AddReportBlocks(const RtcpReportBlock& report_block,
                                  std::vector<uint8>* packet) const {
@@ skipping 28 matching lines @@
   DCHECK_LT(start_size +  12 + c_name_.length(), kIpPacketSize)
       << "Not enough buffer space";
   if (start_size + 12 > kIpPacketSize) return;
 
   // SDES Source Description.
   packet->resize(start_size + 10);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10);
   // We always need to add one SDES CNAME.
   big_endian_writer.WriteU8(0x80 + 1);
-  big_endian_writer.WriteU8(202);
+  big_endian_writer.WriteU8(kPacketTypeSdes);
 
   // Handle SDES length later on.
   uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
   big_endian_writer.WriteU16(0);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(1);  // CNAME = 1
   big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length()));
 
   size_t sdes_length = 10 + c_name_.length();
   packet->insert(packet->end(), c_name_.c_str(),
@@ skipping 21 matching lines @@
                           std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 12, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 12 > kIpPacketSize) return;
 
   packet->resize(start_size + 12);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 12);
   uint8 FMT = 1;  // Picture loss indicator.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(206);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU16(2);  // Used fixed length of 2.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(remote_ssrc);  // Add the remote SSRC.
   TRACE_EVENT_INSTANT2("cast_rtcp", "RtcpSender::PLI", TRACE_EVENT_SCOPE_THREAD,
                        "remote_ssrc", remote_ssrc,
                        "ssrc", ssrc_);
 }
 
 /*
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |      PB       |0| Payload Type|    Native Rpsi bit string     |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |   defined per codec          ...                | Padding (0) |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 void RtcpSender::BuildRpsi(const RtcpRpsiMessage* rpsi,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 24 > kIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
   uint8 FMT = 3;  // Reference Picture Selection Indication.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(206);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
 
   // Calculate length.
   uint32 bits_required = 7;
   uint8 bytes_required = 1;
   while ((rpsi->picture_id >> bits_required) > 0) {
     bits_required += 7;
     bytes_required++;
   }
   uint8 size = 3;
   if (bytes_required > 6) {
@@ skipping 36 matching lines @@
       << "Not enough buffer space";
   if (start_size + remb_size > kIpPacketSize) return;
 
   packet->resize(start_size + remb_size);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), remb_size);
 
   // Add application layer feedback.
   uint8 FMT = 15;
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(206);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU8(0);
   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size() + 4));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(0);  // Remote SSRC must be 0.
   big_endian_writer.WriteU32(kRemb);
   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size()));
 
   // 6 bit exponent and a 18 bit mantissa.
   uint8 bitrate_exponent;
   uint32 bitrate_mantissa;
@@ skipping 19 matching lines @@
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 16, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 16 > kIpPacketSize) return;
 
   packet->resize(start_size + 16);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 16);
 
   uint8 FMT = 1;
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(205);
+  big_endian_writer.WriteU8(kPacketTypeGenericRtpFeedback);
   big_endian_writer.WriteU8(0);
   size_t nack_size_pos = start_size + 3;
   big_endian_writer.WriteU8(3);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(nack->remote_ssrc);  // Add the remote SSRC.
 
   // Build NACK bitmasks and write them to the Rtcp message.
   // The nack list should be sorted and not contain duplicates.
   size_t number_of_nack_fields = 0;
   size_t max_number_of_nack_fields = std::min<size_t>(kRtcpMaxNackFields,
@@ skipping 33 matching lines @@
 
 void RtcpSender::BuildBye(std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 8, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 8 > kIpPacketSize) return;
 
   packet->resize(start_size + 8);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8);
   big_endian_writer.WriteU8(0x80 + 1);
-  big_endian_writer.WriteU8(203);
+  big_endian_writer.WriteU8(kPacketTypeBye);
   big_endian_writer.WriteU16(1);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 }
 
 /*
    0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |V=2|P|reserved |   PT=XR=207   |             length            |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ skipping 11 matching lines @@
 void RtcpSender::BuildDlrrRb(const RtcpDlrrReportBlock* dlrr,
                              std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 24 > kIpPacketSize) return;
 
   packet->resize(start_size + 24);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24);
   big_endian_writer.WriteU8(0x80);
-  big_endian_writer.WriteU8(207);
+  big_endian_writer.WriteU8(kPacketTypeXr);
   big_endian_writer.WriteU16(5);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(5);  // Add block type.
   big_endian_writer.WriteU8(0);  // Add reserved.
   big_endian_writer.WriteU16(3);  // Block length.
   big_endian_writer.WriteU32(ssrc_);  // Add the media (received RTP) SSRC.
   big_endian_writer.WriteU32(dlrr->last_rr);
   big_endian_writer.WriteU32(dlrr->delay_since_last_rr);
 }
 
 void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 20, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 20 > kIpPacketSize) return;
 
   packet->resize(start_size + 20);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 20);
 
   big_endian_writer.WriteU8(0x80);
-  big_endian_writer.WriteU8(207);
+  big_endian_writer.WriteU8(kPacketTypeXr);
   big_endian_writer.WriteU16(4);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(4);  // Add block type.
   big_endian_writer.WriteU8(0);  // Add reserved.
   big_endian_writer.WriteU16(2);  // Block length.
 
   // Add the media (received RTP) SSRC.
   big_endian_writer.WriteU32(rrtr->ntp_seconds);
   big_endian_writer.WriteU32(rrtr->ntp_fraction);
 }
 
 void RtcpSender::BuildCast(const RtcpCastMessage* cast,
                            std::vector<uint8>* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 20, kIpPacketSize) << "Not enough buffer space";
   if (start_size + 20 > kIpPacketSize) return;
 
   packet->resize(start_size + 20);
 
   net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 20);
   uint8 FMT = 15;  // Application layer feedback.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(206);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU8(0);
   size_t cast_size_pos = start_size + 3; // Save length position.
   big_endian_writer.WriteU8(4);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(cast->media_ssrc_);  // Remote SSRC.
   big_endian_writer.WriteU32(kCast);
   big_endian_writer.WriteU8(static_cast<uint8>(cast->ack_frame_id_));
   size_t cast_loss_field_pos = start_size + 17;  // Save loss field position.
   big_endian_writer.WriteU8(0);  // Overwritten with number_of_loss_fields.
   big_endian_writer.WriteU8(0);  // Reserved.
@@ skipping 50 matching lines @@
   }
   DCHECK_LE(number_of_loss_fields, kRtcpMaxCastLossFields);
   (*packet)[cast_size_pos] = static_cast<uint8>(4 + number_of_loss_fields);
   (*packet)[cast_loss_field_pos] = static_cast<uint8>(number_of_loss_fields);
 
   // Frames with missing packets.
   TRACE_COUNTER_ID1("cast_rtcp", "RtcpSender::CastNACK", ssrc_,
                     cast->missing_frames_and_packets_.size());
 }
 
-void RtcpSender::BuildSenderLog(const RtcpSenderLogMessage* sender_log_message,
+void RtcpSender::BuildSenderLog(RtcpSenderLogMessage* sender_log_message,
                                 std::vector<uint8>* packet) const {
-  // TODO(pwestin): Implement.
-  NOTIMPLEMENTED();
+  DCHECK(sender_log_message);
+  DCHECK(packet);
+  size_t start_size = packet->size();
+  size_t remaining_space = kIpPacketSize - start_size;
+  DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
+       << "Not enough buffer space";
+  if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
+    return;
+
+  size_t space_for_x_messages =
+      (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize;
+  size_t number_of_messages = std::min(space_for_x_messages,
+                                       sender_log_message->size());
+
+  size_t log_size = kRtcpCastLogHeaderSize +
+      number_of_messages * kRtcpSenderFrameLogSize;
+  packet->resize(start_size + log_size);
+
+  net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), log_size);
+  big_endian_writer.WriteU8(0x80 + kSenderLogSubtype);
+  big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
+  big_endian_writer.WriteU16(2 + number_of_messages);
+  big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
+  big_endian_writer.WriteU32(kCast);
+
+  for (; number_of_messages > 0; --number_of_messages) {
+    DCHECK(!sender_log_message->empty());
+    const RtcpSenderFrameLogMessage& message = sender_log_message->front();
+    big_endian_writer.WriteU8(static_cast<uint8>(message.frame_status));
+    // We send the 24 east significant bits of the RTP timestamp.
+    big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16));
+    big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8));
+    big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp));
+    sender_log_message->pop_front();
+  }
 }
 
-void RtcpSender::BuildReceiverLog(
-    const RtcpReceiverLogMessage* receiver_log_message,
-    std::vector<uint8>* packet) const {
-  // TODO(pwestin): Implement.
-  NOTIMPLEMENTED();
+void RtcpSender::BuildReceiverLog(RtcpReceiverLogMessage* receiver_log_message,
+                                  std::vector<uint8>* packet) const {
+  DCHECK(receiver_log_message);
+  const size_t packet_start_size = packet->size();
+  size_t number_of_frames = 0;
+  size_t total_number_of_messages_to_send = 0;
+  size_t rtcp_log_size = 0;
+
+  if (!ScanRtcpReceiverLogMessage(*receiver_log_message,
+                                  packet_start_size,
+                                  &number_of_frames,
+                                  &total_number_of_messages_to_send,
+                                  &rtcp_log_size)) {
+    return;
+  }
+  packet->resize(packet_start_size + rtcp_log_size);
+
+  net::BigEndianWriter big_endian_writer(&((*packet)[packet_start_size]),
+                                         rtcp_log_size);
+  big_endian_writer.WriteU8(0x80 + kReceiverLogSubtype);
+  big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
+  big_endian_writer.WriteU16(2 + 2 * number_of_frames +
+                             total_number_of_messages_to_send);
+  big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
+  big_endian_writer.WriteU32(kCast);
+
+  while (!receiver_log_message->empty() &&
+         total_number_of_messages_to_send > 0) {
+    RtcpReceiverFrameLogMessage& frame_log_messages =
+        receiver_log_message->front();
+    // Add our frame header.
+    big_endian_writer.WriteU32(frame_log_messages.rtp_timestamp);
+    size_t messages_in_frame = frame_log_messages.event_log_messages.size();
+    if (messages_in_frame > total_number_of_messages_to_send) {
+      // We are running out of space.
+      messages_in_frame = total_number_of_messages_to_send;
+    }
+    // Keep track of how many messages we have left to send.
+    total_number_of_messages_to_send -= messages_in_frame;
+
+    // On the wire format is number of messages - 1.
+    big_endian_writer.WriteU8(messages_in_frame - 1);
+
+    base::TimeTicks event_timestamp_base =
+        frame_log_messages.event_log_messages.front().event_timestamp;
+    uint32 base_timestamp_ms =
+        (event_timestamp_base - base::TimeTicks()).InMilliseconds();
+    big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms >> 16));
+    big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms >> 8));
+    big_endian_writer.WriteU8(static_cast<uint8>(base_timestamp_ms));
+
+    while (!frame_log_messages.event_log_messages.empty() &&
+           messages_in_frame > 0) {
+      const RtcpReceiverEventLogMessage& event_message =
+          frame_log_messages.event_log_messages.front();
+      uint16 event_type_and_timestamp_delta =
+          MergeEventTypeAndTimestampForWireFormat(event_message.type,
+          event_message.event_timestamp - event_timestamp_base);
+      switch (event_message.type) {
+        case kAckSent:
+        case kAudioPlayoutDelay:
+        case kAudioFrameDecoded:
+        case kVideoFrameDecoded:
+        case kVideoRenderDelay:
+          big_endian_writer.WriteU16(static_cast<uint16>(
+              event_message.delay_delta.InMilliseconds()));
+          big_endian_writer.WriteU16(event_type_and_timestamp_delta);
+          break;
+        case kPacketReceived:
+          big_endian_writer.WriteU16(event_message.packet_id);
+          big_endian_writer.WriteU16(event_type_and_timestamp_delta);
+          break;
+        default:
+          NOTREACHED();
+      }
+      messages_in_frame--;
+      frame_log_messages.event_log_messages.pop_front();
+    }
+    if (frame_log_messages.event_log_messages.empty()) {
+      // We sent all messages on this frame; pop the frame header.
+      receiver_log_message->pop_front();
+    }
+  }
+  DCHECK_EQ(total_number_of_messages_to_send, 0);
 }
 
 }  // namespace cast
 }  // namespace media