OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/cast/transport/rtcp/rtcp_builder.h" | 5 #include "media/cast/transport/rtcp/rtcp_builder.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <string> | 8 #include <string> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
| 11 #include "base/big_endian.h" |
11 #include "base/logging.h" | 12 #include "base/logging.h" |
12 #include "media/cast/transport/cast_transport_defines.h" | 13 #include "media/cast/transport/cast_transport_defines.h" |
13 #include "media/cast/transport/pacing/paced_sender.h" | 14 #include "media/cast/transport/pacing/paced_sender.h" |
14 #include "net/base/big_endian.h" | |
15 | 15 |
16 static const size_t kRtcpCastLogHeaderSize = 12; | 16 static const size_t kRtcpCastLogHeaderSize = 12; |
17 static const size_t kRtcpSenderFrameLogSize = 4; | 17 static const size_t kRtcpSenderFrameLogSize = 4; |
18 | 18 |
19 namespace media { | 19 namespace media { |
20 namespace cast { | 20 namespace cast { |
21 namespace transport { | 21 namespace transport { |
22 | 22 |
23 namespace { | 23 namespace { |
24 // RFC 3550 page 44, including end null. | 24 // RFC 3550 page 44, including end null. |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
78 // Sender report. | 78 // Sender report. |
79 size_t start_size = packet->size(); | 79 size_t start_size = packet->size(); |
80 if (start_size + 52 > kMaxIpPacketSize) { | 80 if (start_size + 52 > kMaxIpPacketSize) { |
81 DLOG(FATAL) << "Not enough buffer space"; | 81 DLOG(FATAL) << "Not enough buffer space"; |
82 return false; | 82 return false; |
83 } | 83 } |
84 | 84 |
85 uint16 number_of_rows = 6; | 85 uint16 number_of_rows = 6; |
86 packet->resize(start_size + 28); | 86 packet->resize(start_size + 28); |
87 | 87 |
88 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 28); | 88 base::BigEndianWriter big_endian_writer( |
| 89 reinterpret_cast<char*>(&((*packet)[start_size])), 28); |
89 big_endian_writer.WriteU8(0x80); | 90 big_endian_writer.WriteU8(0x80); |
90 big_endian_writer.WriteU8(kPacketTypeSenderReport); | 91 big_endian_writer.WriteU8(kPacketTypeSenderReport); |
91 big_endian_writer.WriteU16(number_of_rows); | 92 big_endian_writer.WriteU16(number_of_rows); |
92 big_endian_writer.WriteU32(ssrc_); | 93 big_endian_writer.WriteU32(ssrc_); |
93 big_endian_writer.WriteU32(sender_info.ntp_seconds); | 94 big_endian_writer.WriteU32(sender_info.ntp_seconds); |
94 big_endian_writer.WriteU32(sender_info.ntp_fraction); | 95 big_endian_writer.WriteU32(sender_info.ntp_fraction); |
95 big_endian_writer.WriteU32(sender_info.rtp_timestamp); | 96 big_endian_writer.WriteU32(sender_info.rtp_timestamp); |
96 big_endian_writer.WriteU32(sender_info.send_packet_count); | 97 big_endian_writer.WriteU32(sender_info.send_packet_count); |
97 big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count)); | 98 big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count)); |
98 return true; | 99 return true; |
99 } | 100 } |
100 | 101 |
101 bool RtcpBuilder::BuildSdec(Packet* packet) const { | 102 bool RtcpBuilder::BuildSdec(Packet* packet) const { |
102 size_t start_size = packet->size(); | 103 size_t start_size = packet->size(); |
103 if (start_size + 12 + c_name_.length() > kMaxIpPacketSize) { | 104 if (start_size + 12 + c_name_.length() > kMaxIpPacketSize) { |
104 DLOG(FATAL) << "Not enough buffer space"; | 105 DLOG(FATAL) << "Not enough buffer space"; |
105 return false; | 106 return false; |
106 } | 107 } |
107 | 108 |
108 // SDES Source Description. | 109 // SDES Source Description. |
109 packet->resize(start_size + 10); | 110 packet->resize(start_size + 10); |
110 | 111 |
111 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 10); | 112 base::BigEndianWriter big_endian_writer( |
| 113 reinterpret_cast<char*>(&((*packet)[start_size])), 10); |
112 // We always need to add one SDES CNAME. | 114 // We always need to add one SDES CNAME. |
113 big_endian_writer.WriteU8(0x80 + 1); | 115 big_endian_writer.WriteU8(0x80 + 1); |
114 big_endian_writer.WriteU8(kPacketTypeSdes); | 116 big_endian_writer.WriteU8(kPacketTypeSdes); |
115 | 117 |
116 // Handle SDES length later on. | 118 // Handle SDES length later on. |
117 uint32 sdes_length_position = static_cast<uint32>(start_size) + 3; | 119 uint32 sdes_length_position = static_cast<uint32>(start_size) + 3; |
118 big_endian_writer.WriteU16(0); | 120 big_endian_writer.WriteU16(0); |
119 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. | 121 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. |
120 big_endian_writer.WriteU8(1); // CNAME = 1 | 122 big_endian_writer.WriteU8(1); // CNAME = 1 |
121 big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length())); | 123 big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length())); |
(...skipping 23 matching lines...) Expand all Loading... |
145 | 147 |
146 bool RtcpBuilder::BuildBye(Packet* packet) const { | 148 bool RtcpBuilder::BuildBye(Packet* packet) const { |
147 size_t start_size = packet->size(); | 149 size_t start_size = packet->size(); |
148 if (start_size + 8 > kMaxIpPacketSize) { | 150 if (start_size + 8 > kMaxIpPacketSize) { |
149 DLOG(FATAL) << "Not enough buffer space"; | 151 DLOG(FATAL) << "Not enough buffer space"; |
150 return false; | 152 return false; |
151 } | 153 } |
152 | 154 |
153 packet->resize(start_size + 8); | 155 packet->resize(start_size + 8); |
154 | 156 |
155 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 8); | 157 base::BigEndianWriter big_endian_writer( |
| 158 reinterpret_cast<char*>(&((*packet)[start_size])), 8); |
156 big_endian_writer.WriteU8(0x80 + 1); | 159 big_endian_writer.WriteU8(0x80 + 1); |
157 big_endian_writer.WriteU8(kPacketTypeBye); | 160 big_endian_writer.WriteU8(kPacketTypeBye); |
158 big_endian_writer.WriteU16(1); // Length. | 161 big_endian_writer.WriteU16(1); // Length. |
159 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. | 162 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. |
160 return true; | 163 return true; |
161 } | 164 } |
162 | 165 |
163 /* | 166 /* |
164 0 1 2 3 | 167 0 1 2 3 |
165 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 | 168 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 |
(...skipping 14 matching lines...) Expand all Loading... |
180 bool RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr, | 183 bool RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr, |
181 Packet* packet) const { | 184 Packet* packet) const { |
182 size_t start_size = packet->size(); | 185 size_t start_size = packet->size(); |
183 if (start_size + 24 > kMaxIpPacketSize) { | 186 if (start_size + 24 > kMaxIpPacketSize) { |
184 DLOG(FATAL) << "Not enough buffer space"; | 187 DLOG(FATAL) << "Not enough buffer space"; |
185 return false; | 188 return false; |
186 } | 189 } |
187 | 190 |
188 packet->resize(start_size + 24); | 191 packet->resize(start_size + 24); |
189 | 192 |
190 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), 24); | 193 base::BigEndianWriter big_endian_writer( |
| 194 reinterpret_cast<char*>(&((*packet)[start_size])), 24); |
191 big_endian_writer.WriteU8(0x80); | 195 big_endian_writer.WriteU8(0x80); |
192 big_endian_writer.WriteU8(kPacketTypeXr); | 196 big_endian_writer.WriteU8(kPacketTypeXr); |
193 big_endian_writer.WriteU16(5); // Length. | 197 big_endian_writer.WriteU16(5); // Length. |
194 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. | 198 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. |
195 big_endian_writer.WriteU8(5); // Add block type. | 199 big_endian_writer.WriteU8(5); // Add block type. |
196 big_endian_writer.WriteU8(0); // Add reserved. | 200 big_endian_writer.WriteU8(0); // Add reserved. |
197 big_endian_writer.WriteU16(3); // Block length. | 201 big_endian_writer.WriteU16(3); // Block length. |
198 big_endian_writer.WriteU32(ssrc_); // Add the media (received RTP) SSRC. | 202 big_endian_writer.WriteU32(ssrc_); // Add the media (received RTP) SSRC. |
199 big_endian_writer.WriteU32(dlrr.last_rr); | 203 big_endian_writer.WriteU32(dlrr.last_rr); |
200 big_endian_writer.WriteU32(dlrr.delay_since_last_rr); | 204 big_endian_writer.WriteU32(dlrr.delay_since_last_rr); |
(...skipping 12 matching lines...) Expand all Loading... |
213 | 217 |
214 size_t space_for_x_messages = | 218 size_t space_for_x_messages = |
215 (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize; | 219 (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize; |
216 size_t number_of_messages = std::min(space_for_x_messages, | 220 size_t number_of_messages = std::min(space_for_x_messages, |
217 sender_log_message.size()); | 221 sender_log_message.size()); |
218 | 222 |
219 size_t log_size = kRtcpCastLogHeaderSize + | 223 size_t log_size = kRtcpCastLogHeaderSize + |
220 number_of_messages * kRtcpSenderFrameLogSize; | 224 number_of_messages * kRtcpSenderFrameLogSize; |
221 packet->resize(start_size + log_size); | 225 packet->resize(start_size + log_size); |
222 | 226 |
223 net::BigEndianWriter big_endian_writer(&((*packet)[start_size]), log_size); | 227 base::BigEndianWriter big_endian_writer( |
| 228 reinterpret_cast<char*>(&((*packet)[start_size])), log_size); |
224 big_endian_writer.WriteU8(0x80 + kSenderLogSubtype); | 229 big_endian_writer.WriteU8(0x80 + kSenderLogSubtype); |
225 big_endian_writer.WriteU8(kPacketTypeApplicationDefined); | 230 big_endian_writer.WriteU8(kPacketTypeApplicationDefined); |
226 big_endian_writer.WriteU16(static_cast<uint16>(2 + number_of_messages)); | 231 big_endian_writer.WriteU16(static_cast<uint16>(2 + number_of_messages)); |
227 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. | 232 big_endian_writer.WriteU32(ssrc_); // Add our own SSRC. |
228 big_endian_writer.WriteU32(kCast); | 233 big_endian_writer.WriteU32(kCast); |
229 | 234 |
230 std::vector<RtcpSenderFrameLogMessage>::const_iterator it = | 235 std::vector<RtcpSenderFrameLogMessage>::const_iterator it = |
231 sender_log_message.begin(); | 236 sender_log_message.begin(); |
232 for (; number_of_messages > 0; --number_of_messages) { | 237 for (; number_of_messages > 0; --number_of_messages) { |
233 DCHECK(!sender_log_message.empty()); | 238 DCHECK(!sender_log_message.empty()); |
234 const RtcpSenderFrameLogMessage& message = *it; | 239 const RtcpSenderFrameLogMessage& message = *it; |
235 big_endian_writer.WriteU8(static_cast<uint8>(message.frame_status)); | 240 big_endian_writer.WriteU8(static_cast<uint8>(message.frame_status)); |
236 // We send the 24 east significant bits of the RTP timestamp. | 241 // We send the 24 east significant bits of the RTP timestamp. |
237 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16)); | 242 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 16)); |
238 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8)); | 243 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp >> 8)); |
239 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp)); | 244 big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp)); |
240 ++it; | 245 ++it; |
241 } | 246 } |
242 return true; | 247 return true; |
243 } | 248 } |
244 | 249 |
245 } // namespace transport | 250 } // namespace transport |
246 } // namespace cast | 251 } // namespace cast |
247 } // namespace media | 252 } // namespace media |
OLD | NEW |