OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
71 uint8_t id = data()[extension_entries_[i].offset - 1] >> 4; | 71 uint8_t id = data()[extension_entries_[i].offset - 1] >> 4; |
72 extension_entries_[i].type = extensions_->GetType(id); | 72 extension_entries_[i].type = extensions_->GetType(id); |
73 } | 73 } |
74 } | 74 } |
75 | 75 |
76 bool Packet::Parse(const uint8_t* buffer, size_t buffer_size) { | 76 bool Packet::Parse(const uint8_t* buffer, size_t buffer_size) { |
77 if (!ParseBuffer(buffer, buffer_size)) { | 77 if (!ParseBuffer(buffer, buffer_size)) { |
78 Clear(); | 78 Clear(); |
79 return false; | 79 return false; |
80 } | 80 } |
| 81 buffer_.SetData(buffer, buffer_size); |
81 RTC_DCHECK_EQ(size(), buffer_size); | 82 RTC_DCHECK_EQ(size(), buffer_size); |
82 buffer_.SetData(buffer, buffer_size); | |
83 return true; | 83 return true; |
84 } | 84 } |
85 | 85 |
86 bool Packet::Parse(rtc::Buffer buffer) { | 86 bool Packet::Parse(rtc::CopyOnWriteBuffer buffer) { |
87 if (!ParseBuffer(buffer.data(), buffer.size())) { | 87 if (!ParseBuffer(buffer.cdata(), buffer.size())) { |
88 Clear(); | 88 Clear(); |
89 return false; | 89 return false; |
90 } | 90 } |
91 RTC_DCHECK_EQ(size(), buffer.size()); | 91 size_t buffer_size = buffer.size(); |
92 buffer_ = std::move(buffer); | 92 buffer_ = std::move(buffer); |
| 93 RTC_DCHECK_EQ(size(), buffer_size); |
93 return true; | 94 return true; |
94 } | 95 } |
95 | 96 |
96 bool Packet::Marker() const { | 97 bool Packet::Marker() const { |
97 RTC_DCHECK_EQ(marker_, (data()[1] & 0x80) != 0); | 98 RTC_DCHECK_EQ(marker_, (data()[1] & 0x80) != 0); |
98 return marker_; | 99 return marker_; |
99 } | 100 } |
100 | 101 |
101 uint8_t Packet::PayloadType() const { | 102 uint8_t Packet::PayloadType() const { |
102 RTC_DCHECK_EQ(payload_type_, data()[1] & 0x7f); | 103 RTC_DCHECK_EQ(payload_type_, data()[1] & 0x7f); |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
167 } | 168 } |
168 | 169 |
169 size_t Packet::padding_size() const { | 170 size_t Packet::padding_size() const { |
170 return padding_size_; | 171 return padding_size_; |
171 } | 172 } |
172 | 173 |
173 const uint8_t* Packet::payload() const { | 174 const uint8_t* Packet::payload() const { |
174 return data() + payload_offset_; | 175 return data() + payload_offset_; |
175 } | 176 } |
176 | 177 |
| 178 rtc::CopyOnWriteBuffer Packet::Buffer() const { |
| 179 return buffer_; |
| 180 } |
| 181 |
177 size_t Packet::capacity() const { | 182 size_t Packet::capacity() const { |
178 return buffer_.size(); | 183 return buffer_.capacity(); |
179 } | 184 } |
180 | 185 |
181 size_t Packet::size() const { | 186 size_t Packet::size() const { |
182 return payload_offset_ + payload_size_ + padding_size_; | 187 size_t ret = payload_offset_ + payload_size_ + padding_size_; |
| 188 RTC_DCHECK_EQ(buffer_.size(), ret); |
| 189 return ret; |
183 } | 190 } |
184 | 191 |
185 const uint8_t* Packet::data() const { | 192 const uint8_t* Packet::data() const { |
186 return buffer_.data(); | 193 return buffer_.cdata(); |
187 } | 194 } |
188 | 195 |
189 size_t Packet::FreeCapacity() const { | 196 size_t Packet::FreeCapacity() const { |
190 return capacity() - size(); | 197 return capacity() - size(); |
191 } | 198 } |
192 | 199 |
193 size_t Packet::MaxPayloadSize() const { | 200 size_t Packet::MaxPayloadSize() const { |
194 return capacity() - payload_offset_; | 201 return capacity() - payload_offset_; |
195 } | 202 } |
196 | 203 |
197 void Packet::CopyHeader(const Packet& packet) { | 204 void Packet::CopyHeaderFrom(const Packet& packet) { |
198 RTC_DCHECK_GE(capacity(), packet.headers_size()); | 205 RTC_DCHECK_GE(capacity(), packet.headers_size()); |
199 | 206 |
200 marker_ = packet.marker_; | 207 marker_ = packet.marker_; |
201 payload_type_ = packet.payload_type_; | 208 payload_type_ = packet.payload_type_; |
202 sequence_number_ = packet.sequence_number_; | 209 sequence_number_ = packet.sequence_number_; |
203 timestamp_ = packet.timestamp_; | 210 timestamp_ = packet.timestamp_; |
204 ssrc_ = packet.ssrc_; | 211 ssrc_ = packet.ssrc_; |
205 payload_offset_ = packet.payload_offset_; | 212 payload_offset_ = packet.payload_offset_; |
206 num_extensions_ = packet.num_extensions_; | 213 num_extensions_ = packet.num_extensions_; |
207 for (size_t i = 0; i < num_extensions_; ++i) { | 214 for (size_t i = 0; i < num_extensions_; ++i) { |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
250 RTC_DCHECK_EQ(padding_size_, 0u); | 257 RTC_DCHECK_EQ(padding_size_, 0u); |
251 RTC_DCHECK_LE(csrcs.size(), 0x0fu); | 258 RTC_DCHECK_LE(csrcs.size(), 0x0fu); |
252 RTC_DCHECK_LE(kFixedHeaderSize + 4 * csrcs.size(), capacity()); | 259 RTC_DCHECK_LE(kFixedHeaderSize + 4 * csrcs.size(), capacity()); |
253 payload_offset_ = kFixedHeaderSize + 4 * csrcs.size(); | 260 payload_offset_ = kFixedHeaderSize + 4 * csrcs.size(); |
254 WriteAt(0, (data()[0] & 0xF0) | csrcs.size()); | 261 WriteAt(0, (data()[0] & 0xF0) | csrcs.size()); |
255 size_t offset = kFixedHeaderSize; | 262 size_t offset = kFixedHeaderSize; |
256 for (uint32_t csrc : csrcs) { | 263 for (uint32_t csrc : csrcs) { |
257 ByteWriter<uint32_t>::WriteBigEndian(WriteAt(offset), csrc); | 264 ByteWriter<uint32_t>::WriteBigEndian(WriteAt(offset), csrc); |
258 offset += 4; | 265 offset += 4; |
259 } | 266 } |
| 267 buffer_.SetSize(payload_offset_); |
260 } | 268 } |
261 | 269 |
262 uint8_t* Packet::AllocatePayload(size_t size_bytes) { | 270 uint8_t* Packet::AllocatePayload(size_t size_bytes) { |
263 RTC_DCHECK_EQ(padding_size_, 0u); | 271 RTC_DCHECK_EQ(padding_size_, 0u); |
264 if (payload_offset_ + size_bytes > capacity()) { | 272 if (payload_offset_ + size_bytes > capacity()) { |
265 LOG(LS_WARNING) << "Cannot set payload, not enough space in buffer."; | 273 LOG(LS_WARNING) << "Cannot set payload, not enough space in buffer."; |
266 return nullptr; | 274 return nullptr; |
267 } | 275 } |
268 payload_size_ = size_bytes; | 276 payload_size_ = size_bytes; |
| 277 buffer_.SetSize(payload_offset_ + payload_size_); |
269 return WriteAt(payload_offset_); | 278 return WriteAt(payload_offset_); |
270 } | 279 } |
271 | 280 |
272 void Packet::SetPayloadSize(size_t size_bytes) { | 281 void Packet::SetPayloadSize(size_t size_bytes) { |
273 RTC_DCHECK_EQ(padding_size_, 0u); | 282 RTC_DCHECK_EQ(padding_size_, 0u); |
274 RTC_DCHECK_LE(size_bytes, payload_size_); | 283 RTC_DCHECK_LE(size_bytes, payload_size_); |
275 payload_size_ = size_bytes; | 284 payload_size_ = size_bytes; |
| 285 buffer_.SetSize(payload_offset_ + payload_size_); |
276 } | 286 } |
277 | 287 |
278 bool Packet::SetPadding(uint8_t size_bytes, Random* random) { | 288 bool Packet::SetPadding(uint8_t size_bytes, Random* random) { |
279 RTC_DCHECK(random); | 289 RTC_DCHECK(random); |
280 if (payload_offset_ + payload_size_ + size_bytes > capacity()) { | 290 if (payload_offset_ + payload_size_ + size_bytes > capacity()) { |
281 LOG(LS_WARNING) << "Cannot set padding size " << size_bytes << ", only " | 291 LOG(LS_WARNING) << "Cannot set padding size " << size_bytes << ", only " |
282 << (capacity() - payload_offset_ - payload_size_) | 292 << (capacity() - payload_offset_ - payload_size_) |
283 << " bytes left in buffer."; | 293 << " bytes left in buffer."; |
284 return false; | 294 return false; |
285 } | 295 } |
286 padding_size_ = size_bytes; | 296 padding_size_ = size_bytes; |
| 297 buffer_.SetSize(payload_offset_ + payload_size_ + padding_size_); |
287 if (padding_size_ > 0) { | 298 if (padding_size_ > 0) { |
288 size_t padding_offset = payload_offset_ + payload_size_; | 299 size_t padding_offset = payload_offset_ + payload_size_; |
289 size_t padding_end = padding_offset + padding_size_; | 300 size_t padding_end = padding_offset + padding_size_; |
290 for (size_t offset = padding_offset; offset < padding_end - 1; ++offset) { | 301 for (size_t offset = padding_offset; offset < padding_end - 1; ++offset) { |
291 WriteAt(offset, random->Rand<uint8_t>()); | 302 WriteAt(offset, random->Rand<uint8_t>()); |
292 } | 303 } |
293 WriteAt(padding_end - 1, padding_size_); | 304 WriteAt(padding_end - 1, padding_size_); |
294 WriteAt(0, data()[0] | 0x20); // Set padding bit. | 305 WriteAt(0, data()[0] | 0x20); // Set padding bit. |
295 } else { | 306 } else { |
296 WriteAt(0, data()[0] & ~0x20); // Clear padding bit. | 307 WriteAt(0, data()[0] & ~0x20); // Clear padding bit. |
297 } | 308 } |
298 return true; | 309 return true; |
299 } | 310 } |
300 | 311 |
301 void Packet::Clear() { | 312 void Packet::Clear() { |
302 marker_ = false; | 313 marker_ = false; |
303 payload_type_ = 0; | 314 payload_type_ = 0; |
304 sequence_number_ = 0; | 315 sequence_number_ = 0; |
305 timestamp_ = 0; | 316 timestamp_ = 0; |
306 ssrc_ = 0; | 317 ssrc_ = 0; |
307 payload_offset_ = kFixedHeaderSize; | 318 payload_offset_ = kFixedHeaderSize; |
308 payload_size_ = 0; | 319 payload_size_ = 0; |
309 padding_size_ = 0; | 320 padding_size_ = 0; |
310 num_extensions_ = 0; | 321 num_extensions_ = 0; |
311 extensions_size_ = 0; | 322 extensions_size_ = 0; |
312 | 323 |
313 memset(WriteAt(0), 0, kFixedHeaderSize); | 324 memset(WriteAt(0), 0, kFixedHeaderSize); |
| 325 buffer_.SetSize(kFixedHeaderSize); |
314 WriteAt(0, kRtpVersion << 6); | 326 WriteAt(0, kRtpVersion << 6); |
315 } | 327 } |
316 | 328 |
317 bool Packet::ParseBuffer(const uint8_t* buffer, size_t size) { | 329 bool Packet::ParseBuffer(const uint8_t* buffer, size_t size) { |
318 if (size < kFixedHeaderSize) { | 330 if (size < kFixedHeaderSize) { |
319 return false; | 331 return false; |
320 } | 332 } |
321 const uint8_t version = buffer[0] >> 6; | 333 const uint8_t version = buffer[0] >> 6; |
322 if (version != kRtpVersion) { | 334 if (version != kRtpVersion) { |
323 return false; | 335 return false; |
(...skipping 166 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
490 extensions_size_ = new_extensions_size; | 502 extensions_size_ = new_extensions_size; |
491 | 503 |
492 // Update header length field. | 504 // Update header length field. |
493 ByteWriter<uint16_t>::WriteBigEndian(WriteAt(extensions_offset - 2), | 505 ByteWriter<uint16_t>::WriteBigEndian(WriteAt(extensions_offset - 2), |
494 extensions_words); | 506 extensions_words); |
495 // Fill extension padding place with zeroes. | 507 // Fill extension padding place with zeroes. |
496 size_t extension_padding_size = 4 * extensions_words - extensions_size_; | 508 size_t extension_padding_size = 4 * extensions_words - extensions_size_; |
497 memset(WriteAt(extensions_offset + extensions_size_), 0, | 509 memset(WriteAt(extensions_offset + extensions_size_), 0, |
498 extension_padding_size); | 510 extension_padding_size); |
499 payload_offset_ = extensions_offset + 4 * extensions_words; | 511 payload_offset_ = extensions_offset + 4 * extensions_words; |
| 512 buffer_.SetSize(payload_offset_); |
500 return true; | 513 return true; |
501 } | 514 } |
502 | 515 |
503 uint8_t* Packet::WriteAt(size_t offset) { | 516 uint8_t* Packet::WriteAt(size_t offset) { |
504 return buffer_.data() + offset; | 517 return buffer_.data() + offset; |
505 } | 518 } |
506 | 519 |
507 void Packet::WriteAt(size_t offset, uint8_t byte) { | 520 void Packet::WriteAt(size_t offset, uint8_t byte) { |
508 buffer_.data()[offset] = byte; | 521 buffer_.data()[offset] = byte; |
509 } | 522 } |
510 | 523 |
511 } // namespace rtp | 524 } // namespace rtp |
512 } // namespace webrtc | 525 } // namespace webrtc |
OLD | NEW |