| OLD | NEW |
|---|
| (Empty) |
| 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 #include "media/cast/net/rtcp/rtcp_builder.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <string> | |
| 9 #include <vector> | |
| 10 | |
| 11 #include "base/logging.h" | |
| 12 #include "media/cast/net/cast_net_defines.h" | |
| 13 #include "media/cast/net/pacing/paced_sender.h" | |
| 14 #include "media/cast/rtcp/rtcp_utility.h" | |
| 15 #include "net/base/big_endian.h" | |
| 16 | |
| 17 static const size_t kRtcpCastLogHeaderSize = 12; | |
| 18 static const size_t kRtcpSenderFrameLogSize = 4; | |
| 19 static const size_t kRtcpReceiverFrameLogSize = 8; | |
| 20 static const size_t kRtcpReceiverEventLogSize = 4; | |
| 21 | |
| 22 namespace media { | |
| 23 namespace cast { | |
| 24 | |
| 25 RtcpBuilder::RtcpBuilder(PacedPacketSender* outgoing_transport, | |
| 26 uint32 sending_ssrc, | |
| 27 const std::string& c_name) | |
| 28 : ssrc_(sending_ssrc), | |
| 29 c_name_(c_name), | |
| 30 transport_(outgoing_transport) { | |
| 31 DCHECK_LT(c_name_.length(), kRtcpCnameSize) << "Invalid config"; | |
| 32 } | |
| 33 | |
| 34 RtcpBuilder::~RtcpBuilder() {} | |
| 35 | |
| 36 void RtcpBuilder::SendRtcpFromRtpSender(uint32 packet_type_flags, | |
| 37 const RtcpSenderInfo* sender_info, | |
| 38 const RtcpDlrrReportBlock* dlrr, | |
| 39 RtcpSenderLogMessage* sender_log) { | |
| 40 if (packet_type_flags & kRtcpRr || | |
| 41 packet_type_flags & kRtcpPli || | |
| 42 packet_type_flags & kRtcpRrtr || | |
| 43 packet_type_flags & kRtcpCast || | |
| 44 packet_type_flags & kRtcpReceiverLog || | |
| 45 packet_type_flags & kRtcpRpsi || | |
| 46 packet_type_flags & kRtcpRemb || | |
| 47 packet_type_flags & kRtcpNack) { | |
| 48 NOTREACHED() << "Invalid argument"; | |
| 49 } | |
| 50 | |
| 51 std::vector<uint8> packet; | |
| 52 packet.reserve(kIpPacketSize); | |
| 53 if (packet_type_flags & kRtcpSr) { | |
| 54 DCHECK(sender_info) << "Invalid argument"; | |
| 55 BuildSR(*sender_info, NULL, &packet); | |
| 56 BuildSdec(&packet); | |
| 57 } | |
| 58 if (packet_type_flags & kRtcpBye) { | |
| 59 BuildBye(&packet); | |
| 60 } | |
| 61 if (packet_type_flags & kRtcpDlrr) { | |
| 62 DCHECK(dlrr) << "Invalid argument"; | |
| 63 BuildDlrrRb(dlrr, &packet); | |
| 64 } | |
| 65 if (packet_type_flags & kRtcpSenderLog) { | |
| 66 DCHECK(sender_log) << "Invalid argument"; | |
| 67 BuildSenderLog(sender_log, &packet); | |
| 68 } | |
| 69 if (packet.empty()) | |
| 70 return; // Sanity don't send empty packets. | |
| 71 | |
| 72 transport_->SendRtcpPacket(packet); | |
| 73 } | |
| 74 | |
| 75 void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info, | |
| 76 const RtcpReportBlock* report_block, | |
| 77 std::vector<uint8>* packet) const { | |
| 78 // Sender report. | |
| 79 size_t start_size = packet->size(); | |
| 80 DCHECK_LT(start_size + 52, kIpPacketSize) << "Not enough buffer space"; | |
| 81 if (start_size + 52 > kIpPacketSize) return; | |
| 82 | |
| 83 uint16 number_of_rows = (report_block) ? 12 : 6; | |
| 84 packet->resize(start_size + 28); | |
| 85 | |
| 86 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28); | |
| 87 big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0)); | |
| 88 big_endian_writer.WriteU8(kPacketTypeSenderReport); | |
| 89 big_endian_writer.WriteU16(number_of_rows); | |
| 90 big_endian_writer.WriteU32(ssrc_); | |
| 91 big_endian_writer.WriteU32(sender_info.ntp_seconds); | |
| 92 big_endian_writer.WriteU32(sender_info.ntp_fraction); | |
| 93 big_endian_writer.WriteU32(sender_info.rtp_timestamp); | |
| 94 big_endian_writer.WriteU32(sender_info.send_packet_count); | |
| 95 big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count)); | |
| 96 | |
| 97 if (report_block) { | |
| 98 AddReportBlocks(*report_block, packet); // Adds 24 bytes. | |
| 99 } | |
| 100 } | |
| 101 | |
| 102 void RtcpBuilder::AddReportBlocks(const RtcpReportBlock& report_block, | |
| 103 std::vector<uint8>* packet) const { | |
| 104 size_t start_size = packet->size(); | |
| 105 DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space"; | |
| 106 if (start_size + 24 > kIpPacketSize) return; | |
| 107 | |
| 108 packet->resize(start_size + 24); | |
| 109 | |
| 110 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24); | |
| 111 big_endian_writer.WriteU32(report_block.media_ssrc); | |
| 112 big_endian_writer.WriteU8(report_block.fraction_lost); | |
| 113 big_endian_writer.WriteU8(report_block.cumulative_lost >> 16); | |
| 114 big_endian_writer.WriteU8(report_block.cumulative_lost >> 8); | |
| 115 big_endian_writer.WriteU8(report_block.cumulative_lost); | |
| 116 | |
| 117 // Extended highest seq_no, contain the highest sequence number received. | |
| 118 big_endian_writer.WriteU32(report_block.extended_high_sequence_number); | |
| 119 big_endian_writer.WriteU32(report_block.jitter); | |
| 120 | |
| 121 // Last SR timestamp; our NTP time when we received the last report. | |
| 122 // This is the value that we read from the send report packet not when we | |
| 123 // received it. | |
| 124 big_endian_writer.WriteU32(report_block.last_sr); | |
| 125 | |
| 126 // Delay since last received report, time since we received the report. | |
| 127 big_endian_writer.WriteU32(report_block.delay_since_last_sr); | |
| 128 } | |
| 129 | |
| 130 void RtcpBuilder::BuildSdec(std::vector<uint8>* packet) const { | |
| 131 size_t start_size = packet->size(); | |
| 132 DCHECK_LT(start_size + 12 + c_name_.length(), kIpPacketSize) | |
| 133 << "Not enough buffer space"; | |
| 134 if (start_size + 12 > kIpPacketSize) return; | |
| 135 | |
| 136 // SDES Source Description. | |
| 137 packet->resize(start_size + 10); | |
| 138 | |
| 139 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10); | |
| 140 // We always need to add one SDES CNAME. | |
| 141 big_endian_writer.WriteU8(0x80 + 1); | |
| 142 big_endian_writer.WriteU8(kPacketTypeSdes); | |
| 143 | |
| 144 // Handle SDES length later on. | |
| 145 uint32 sdes_length_position = static_cast<uint32>(start_size) + 3; | |
| 146 big_endian_writer.WriteU16(0); | |
| 147 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. | |
| 148 big_endian_writer.WriteU8(1); // CNAME = 1 | |
| 149 big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length())); | |
| 150 | |
| 151 size_t sdes_length = 10 + c_name_.length(); | |
| 152 packet->insert(packet->end(), c_name_.c_str(), | |
| 153 c_name_.c_str() + c_name_.length()); | |
| 154 | |
| 155 size_t padding = 0; | |
| 156 | |
| 157 // We must have a zero field even if we have an even multiple of 4 bytes. | |
| 158 if ((packet->size() % 4) == 0) { | |
| 159 padding++; | |
| 160 packet->push_back(0); | |
| 161 } | |
| 162 while ((packet->size() % 4) != 0) { | |
| 163 padding++; | |
| 164 packet->push_back(0); | |
| 165 } | |
| 166 sdes_length += padding; | |
| 167 | |
| 168 // In 32-bit words minus one and we don't count the header. | |
| 169 uint8 buffer_length = static_cast<uint8>((sdes_length / 4) - 1); | |
| 170 (*packet)[sdes_length_position] = buffer_length; | |
| 171 } | |
| 172 | |
| 173 void RtcpBuilder::BuildBye(std::vector<uint8>* packet) const { | |
| 174 size_t start_size = packet->size(); | |
| 175 DCHECK_LT(start_size + 8, kIpPacketSize) << "Not enough buffer space"; | |
| 176 if (start_size + 8 > kIpPacketSize) return; | |
| 177 | |
| 178 packet->resize(start_size + 8); | |
| 179 | |
| 180 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8); | |
| 181 big_endian_writer.WriteU8(0x80 + 1); | |
| 182 big_endian_writer.WriteU8(kPacketTypeBye); | |
| 183 big_endian_writer.WriteU16(1); // Length. | |
| 184 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. | |
| 185 } | |
| 186 | |
| 187 /* | |
| 188 0 1 2 3 | |
| 189 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 | |
| 190 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| 191 |V=2|P|reserved | PT=XR=207 | length | | |
| 192 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| 193 | SSRC | | |
| 194 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| 195 | BT=5 | reserved | block length | | |
| 196 +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ | |
| 197 | SSRC_1 (SSRC of first receiver) | sub- | |
| 198 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block | |
| 199 | last RR (LRR) | 1 | |
| 200 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | |
| 201 | delay since last RR (DLRR) | | |
| 202 +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ | |
| 203 */ | |
| 204 void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock* dlrr, | |
| 205 std::vector<uint8>* packet) const { | |
| 206 size_t start_size = packet->size(); | |
| 207 DCHECK_LT(start_size + 24, kIpPacketSize) << "Not enough buffer space"; | |
| 208 if (start_size + 24 > kIpPacketSize) return; | |
| 209 | |
| 210 packet->resize(start_size + 24); | |
| 211 | |
| 212 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24); | |
| 213 big_endian_writer.WriteU8(0x80); | |
| 214 big_endian_writer.WriteU8(kPacketTypeXr); | |
| 215 big_endian_writer.WriteU16(5); // Length. | |
| 216 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. | |
| 217 big_endian_writer.WriteU8(5); // Add block type. | |
| 218 big_endian_writer.WriteU8(0); // Add reserved. | |
| 219 big_endian_writer.WriteU16(3); // Block length. | |
| 220 big_endian_writer.WriteU32(ssrc_); // Add the media (received RTP) SSRC. | |
| 221 big_endian_writer.WriteU32(dlrr->last_rr); | |
| 222 big_endian_writer.WriteU32(dlrr->delay_since_last_rr); | |
| 223 } | |
| 224 | |
| 225 void RtcpBuilder::BuildSenderLog(RtcpSenderLogMessage* sender_log_message, | |
| 226 std::vector<uint8>* packet) const { | |
| 227 DCHECK(sender_log_message); | |
| 228 DCHECK(packet); | |
| 229 size_t start_size = packet->size(); | |
| 230 size_t remaining_space = kIpPacketSize - start_size; | |
| 231 DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize) | |
| 232 << "Not enough buffer space"; | |
| 233 if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize) | |
| 234 return; | |
| 235 | |
| 236 size_t space_for_x_messages = | |
| 237 (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize; | |
| 238 size_t number_of_messages = std::min(space_for_x_messages, | |
| 239 sender_log_message->size()); | |
| 240 | |
| 241 size_t log_size = kRtcpCastLogHeaderSize + | |
| 242 number_of_messages * kRtcpSenderFrameLogSize; | |
| 243 packet->resize(start_size + log_size); | |
| 244 | |
| 245 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), log_size); | |
| 246 big_endian_writer.WriteU8(0x80 + kSenderLogSubtype); | |
| 247 big_endian_writer.WriteU8(kPacketTypeApplicationDefined); | |
| 248 big_endian_writer.WriteU16(static_cast<uint16>(2 + number_of_messages)); | |
| 249 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. | |
| 250 big_endian_writer.WriteU32(kCast); | |
| 251 | |
| 252 for (; number_of_messages > 0; --number_of_messages) { | |
| 253 DCHECK(!sender_log_message->empty()); | |
| 254 const RtcpSenderFrameLogMessage& message = sender_log_message->front(); | |
| 255 big_endian_writer.WriteU8(static_cast<uint8>(message.frame_status)); | |
| 256 // We send the 24 east significant bits of the RTP timestamp. | |
| 257 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16)); | |
| 258 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8)); | |
| 259 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp)); | |
| 260 sender_log_message->pop_front(); | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 } // namespace cast | |
| 265 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 100823015:
Cast: move net->transport (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src