| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * libjingle | |
| 3 * Copyright 2010 Google Inc. | |
| 4 * | |
| 5 * Redistribution and use in source and binary forms, with or without | |
| 6 * modification, are permitted provided that the following conditions are met: | |
| 7 * | |
| 8 * 1. Redistributions of source code must retain the above copyright notice, | |
| 9 * this list of conditions and the following disclaimer. | |
| 10 * 2. Redistributions in binary form must reproduce the above copyright notice, | |
| 11 * this list of conditions and the following disclaimer in the documentation | |
| 12 * and/or other materials provided with the distribution. | |
| 13 * 3. The name of the author may not be used to endorse or promote products | |
| 14 * derived from this software without specific prior written permission. | |
| 15 * | |
| 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED | |
| 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
| 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO | |
| 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
| 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | |
| 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
| 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
| 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | |
| 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 26 */ | |
| 27 | |
| 28 #include "talk/media/base/rtpdump.h" | |
| 29 | |
| 30 #include <ctype.h> | |
| 31 | |
| 32 #include <string> | |
| 33 | |
| 34 #include "talk/media/base/rtputils.h" | |
| 35 #include "webrtc/base/byteorder.h" | |
| 36 #include "webrtc/base/logging.h" | |
| 37 #include "webrtc/base/timeutils.h" | |
| 38 | |
| 39 namespace { | |
| 40 static const int kRtpSsrcOffset = 8; | |
| 41 const int kWarnSlowWritesDelayMs = 50; | |
| 42 } // namespace | |
| 43 | |
| 44 namespace cricket { | |
| 45 | |
| 46 const char RtpDumpFileHeader::kFirstLine[] = "#!rtpplay1.0 0.0.0.0/0\n"; | |
| 47 | |
| 48 RtpDumpFileHeader::RtpDumpFileHeader(uint32_t start_ms, uint32_t s, uint16_t p) | |
| 49 : start_sec(start_ms / 1000), | |
| 50 start_usec(start_ms % 1000 * 1000), | |
| 51 source(s), | |
| 52 port(p), | |
| 53 padding(0) { | |
| 54 } | |
| 55 | |
| 56 void RtpDumpFileHeader::WriteToByteBuffer(rtc::ByteBuffer* buf) { | |
| 57 buf->WriteUInt32(start_sec); | |
| 58 buf->WriteUInt32(start_usec); | |
| 59 buf->WriteUInt32(source); | |
| 60 buf->WriteUInt16(port); | |
| 61 buf->WriteUInt16(padding); | |
| 62 } | |
| 63 | |
| 64 static const uint32_t kDefaultTimeIncrease = 30; | |
| 65 | |
| 66 bool RtpDumpPacket::IsValidRtpPacket() const { | |
| 67 return original_data_len >= data.size() && | |
| 68 data.size() >= kMinRtpPacketLen; | |
| 69 } | |
| 70 | |
| 71 bool RtpDumpPacket::IsValidRtcpPacket() const { | |
| 72 return original_data_len == 0 && | |
| 73 data.size() >= kMinRtcpPacketLen; | |
| 74 } | |
| 75 | |
| 76 bool RtpDumpPacket::GetRtpPayloadType(int* pt) const { | |
| 77 return IsValidRtpPacket() && | |
| 78 cricket::GetRtpPayloadType(&data[0], data.size(), pt); | |
| 79 } | |
| 80 | |
| 81 bool RtpDumpPacket::GetRtpSeqNum(int* seq_num) const { | |
| 82 return IsValidRtpPacket() && | |
| 83 cricket::GetRtpSeqNum(&data[0], data.size(), seq_num); | |
| 84 } | |
| 85 | |
| 86 bool RtpDumpPacket::GetRtpTimestamp(uint32_t* ts) const { | |
| 87 return IsValidRtpPacket() && | |
| 88 cricket::GetRtpTimestamp(&data[0], data.size(), ts); | |
| 89 } | |
| 90 | |
| 91 bool RtpDumpPacket::GetRtpSsrc(uint32_t* ssrc) const { | |
| 92 return IsValidRtpPacket() && | |
| 93 cricket::GetRtpSsrc(&data[0], data.size(), ssrc); | |
| 94 } | |
| 95 | |
| 96 bool RtpDumpPacket::GetRtpHeaderLen(size_t* len) const { | |
| 97 return IsValidRtpPacket() && | |
| 98 cricket::GetRtpHeaderLen(&data[0], data.size(), len); | |
| 99 } | |
| 100 | |
| 101 bool RtpDumpPacket::GetRtcpType(int* type) const { | |
| 102 return IsValidRtcpPacket() && | |
| 103 cricket::GetRtcpType(&data[0], data.size(), type); | |
| 104 } | |
| 105 | |
| 106 /////////////////////////////////////////////////////////////////////////// | |
| 107 // Implementation of RtpDumpReader. | |
| 108 /////////////////////////////////////////////////////////////////////////// | |
| 109 | |
| 110 void RtpDumpReader::SetSsrc(uint32_t ssrc) { | |
| 111 ssrc_override_ = ssrc; | |
| 112 } | |
| 113 | |
| 114 rtc::StreamResult RtpDumpReader::ReadPacket(RtpDumpPacket* packet) { | |
| 115 if (!packet) return rtc::SR_ERROR; | |
| 116 | |
| 117 rtc::StreamResult res = rtc::SR_SUCCESS; | |
| 118 // Read the file header if it has not been read yet. | |
| 119 if (!file_header_read_) { | |
| 120 res = ReadFileHeader(); | |
| 121 if (res != rtc::SR_SUCCESS) { | |
| 122 return res; | |
| 123 } | |
| 124 file_header_read_ = true; | |
| 125 } | |
| 126 | |
| 127 // Read the RTP dump packet header. | |
| 128 char header[RtpDumpPacket::kHeaderLength]; | |
| 129 res = stream_->ReadAll(header, sizeof(header), NULL, NULL); | |
| 130 if (res != rtc::SR_SUCCESS) { | |
| 131 return res; | |
| 132 } | |
| 133 rtc::ByteBuffer buf(header, sizeof(header)); | |
| 134 uint16_t dump_packet_len; | |
| 135 uint16_t data_len; | |
| 136 // Read the full length of the rtpdump packet, including the rtpdump header. | |
| 137 buf.ReadUInt16(&dump_packet_len); | |
| 138 packet->data.resize(dump_packet_len - sizeof(header)); | |
| 139 // Read the size of the original packet, which may be larger than the size in | |
| 140 // the rtpdump file, in the event that only part of the packet (perhaps just | |
| 141 // the header) was recorded. Note that this field is set to zero for RTCP | |
| 142 // packets, which have their own internal length field. | |
| 143 buf.ReadUInt16(&data_len); | |
| 144 packet->original_data_len = data_len; | |
| 145 // Read the elapsed time for this packet (different than RTP timestamp). | |
| 146 buf.ReadUInt32(&packet->elapsed_time); | |
| 147 | |
| 148 // Read the actual RTP or RTCP packet. | |
| 149 res = stream_->ReadAll(&packet->data[0], packet->data.size(), NULL, NULL); | |
| 150 | |
| 151 // If the packet is RTP and we have specified a ssrc, replace the RTP ssrc | |
| 152 // with the specified ssrc. | |
| 153 if (res == rtc::SR_SUCCESS && | |
| 154 packet->IsValidRtpPacket() && | |
| 155 ssrc_override_ != 0) { | |
| 156 rtc::SetBE32(&packet->data[kRtpSsrcOffset], ssrc_override_); | |
| 157 } | |
| 158 | |
| 159 return res; | |
| 160 } | |
| 161 | |
| 162 rtc::StreamResult RtpDumpReader::ReadFileHeader() { | |
| 163 // Read the first line. | |
| 164 std::string first_line; | |
| 165 rtc::StreamResult res = stream_->ReadLine(&first_line); | |
| 166 if (res != rtc::SR_SUCCESS) { | |
| 167 return res; | |
| 168 } | |
| 169 if (!CheckFirstLine(first_line)) { | |
| 170 return rtc::SR_ERROR; | |
| 171 } | |
| 172 | |
| 173 // Read the 16 byte file header. | |
| 174 char header[RtpDumpFileHeader::kHeaderLength]; | |
| 175 res = stream_->ReadAll(header, sizeof(header), NULL, NULL); | |
| 176 if (res == rtc::SR_SUCCESS) { | |
| 177 rtc::ByteBuffer buf(header, sizeof(header)); | |
| 178 uint32_t start_sec; | |
| 179 uint32_t start_usec; | |
| 180 buf.ReadUInt32(&start_sec); | |
| 181 buf.ReadUInt32(&start_usec); | |
| 182 start_time_ms_ = start_sec * 1000 + start_usec / 1000; | |
| 183 // Increase the length by 1 since first_line does not contain the ending \n. | |
| 184 first_line_and_file_header_len_ = first_line.size() + 1 + sizeof(header); | |
| 185 } | |
| 186 return res; | |
| 187 } | |
| 188 | |
| 189 bool RtpDumpReader::CheckFirstLine(const std::string& first_line) { | |
| 190 // The first line is like "#!rtpplay1.0 address/port" | |
| 191 bool matched = (0 == first_line.find("#!rtpplay1.0 ")); | |
| 192 | |
| 193 // The address could be IP or hostname. We do not check it here. Instead, we | |
| 194 // check the port at the end. | |
| 195 size_t pos = first_line.find('/'); | |
| 196 matched &= (pos != std::string::npos && pos < first_line.size() - 1); | |
| 197 for (++pos; pos < first_line.size() && matched; ++pos) { | |
| 198 matched &= (0 != isdigit(first_line[pos])); | |
| 199 } | |
| 200 | |
| 201 return matched; | |
| 202 } | |
| 203 | |
| 204 /////////////////////////////////////////////////////////////////////////// | |
| 205 // Implementation of RtpDumpLoopReader. | |
| 206 /////////////////////////////////////////////////////////////////////////// | |
| 207 RtpDumpLoopReader::RtpDumpLoopReader(rtc::StreamInterface* stream) | |
| 208 : RtpDumpReader(stream), | |
| 209 loop_count_(0), | |
| 210 elapsed_time_increases_(0), | |
| 211 rtp_seq_num_increase_(0), | |
| 212 rtp_timestamp_increase_(0), | |
| 213 packet_count_(0), | |
| 214 frame_count_(0), | |
| 215 first_elapsed_time_(0), | |
| 216 first_rtp_seq_num_(0), | |
| 217 first_rtp_timestamp_(0), | |
| 218 prev_elapsed_time_(0), | |
| 219 prev_rtp_seq_num_(0), | |
| 220 prev_rtp_timestamp_(0) { | |
| 221 } | |
| 222 | |
| 223 rtc::StreamResult RtpDumpLoopReader::ReadPacket(RtpDumpPacket* packet) { | |
| 224 if (!packet) return rtc::SR_ERROR; | |
| 225 | |
| 226 rtc::StreamResult res = RtpDumpReader::ReadPacket(packet); | |
| 227 if (rtc::SR_SUCCESS == res) { | |
| 228 if (0 == loop_count_) { | |
| 229 // During the first loop, we update the statistics of the input stream. | |
| 230 UpdateStreamStatistics(*packet); | |
| 231 } | |
| 232 } else if (rtc::SR_EOS == res) { | |
| 233 if (0 == loop_count_) { | |
| 234 // At the end of the first loop, calculate elapsed_time_increases_, | |
| 235 // rtp_seq_num_increase_, and rtp_timestamp_increase_, which will be | |
| 236 // used during the second and later loops. | |
| 237 CalculateIncreases(); | |
| 238 } | |
| 239 | |
| 240 // Rewind the input stream to the first dump packet and read again. | |
| 241 ++loop_count_; | |
| 242 if (RewindToFirstDumpPacket()) { | |
| 243 res = RtpDumpReader::ReadPacket(packet); | |
| 244 } | |
| 245 } | |
| 246 | |
| 247 if (rtc::SR_SUCCESS == res && loop_count_ > 0) { | |
| 248 // During the second and later loops, we update the elapsed time of the dump | |
| 249 // packet. If the dumped packet is a RTP packet, we also update its RTP | |
| 250 // sequence number and timestamp. | |
| 251 UpdateDumpPacket(packet); | |
| 252 } | |
| 253 | |
| 254 return res; | |
| 255 } | |
| 256 | |
| 257 void RtpDumpLoopReader::UpdateStreamStatistics(const RtpDumpPacket& packet) { | |
| 258 // Get the RTP sequence number and timestamp of the dump packet. | |
| 259 int rtp_seq_num = 0; | |
| 260 packet.GetRtpSeqNum(&rtp_seq_num); | |
| 261 uint32_t rtp_timestamp = 0; | |
| 262 packet.GetRtpTimestamp(&rtp_timestamp); | |
| 263 | |
| 264 // Set the timestamps and sequence number for the first dump packet. | |
| 265 if (0 == packet_count_++) { | |
| 266 first_elapsed_time_ = packet.elapsed_time; | |
| 267 first_rtp_seq_num_ = rtp_seq_num; | |
| 268 first_rtp_timestamp_ = rtp_timestamp; | |
| 269 // The first packet belongs to a new payload frame. | |
| 270 ++frame_count_; | |
| 271 } else if (rtp_timestamp != prev_rtp_timestamp_) { | |
| 272 // The current and previous packets belong to different payload frames. | |
| 273 ++frame_count_; | |
| 274 } | |
| 275 | |
| 276 prev_elapsed_time_ = packet.elapsed_time; | |
| 277 prev_rtp_timestamp_ = rtp_timestamp; | |
| 278 prev_rtp_seq_num_ = rtp_seq_num; | |
| 279 } | |
| 280 | |
| 281 void RtpDumpLoopReader::CalculateIncreases() { | |
| 282 // At this time, prev_elapsed_time_, prev_rtp_seq_num_, and | |
| 283 // prev_rtp_timestamp_ are values of the last dump packet in the input stream. | |
| 284 rtp_seq_num_increase_ = prev_rtp_seq_num_ - first_rtp_seq_num_ + 1; | |
| 285 // If we have only one packet or frame, we use the default timestamp | |
| 286 // increase. Otherwise, we use the difference between the first and the last | |
| 287 // packets or frames. | |
| 288 elapsed_time_increases_ = packet_count_ <= 1 ? kDefaultTimeIncrease : | |
| 289 (prev_elapsed_time_ - first_elapsed_time_) * packet_count_ / | |
| 290 (packet_count_ - 1); | |
| 291 rtp_timestamp_increase_ = frame_count_ <= 1 ? kDefaultTimeIncrease : | |
| 292 (prev_rtp_timestamp_ - first_rtp_timestamp_) * frame_count_ / | |
| 293 (frame_count_ - 1); | |
| 294 } | |
| 295 | |
| 296 void RtpDumpLoopReader::UpdateDumpPacket(RtpDumpPacket* packet) { | |
| 297 // Increase the elapsed time of the dump packet. | |
| 298 packet->elapsed_time += loop_count_ * elapsed_time_increases_; | |
| 299 | |
| 300 if (packet->IsValidRtpPacket()) { | |
| 301 // Get the old RTP sequence number and timestamp. | |
| 302 int sequence = 0; | |
| 303 packet->GetRtpSeqNum(&sequence); | |
| 304 uint32_t timestamp = 0; | |
| 305 packet->GetRtpTimestamp(×tamp); | |
| 306 // Increase the RTP sequence number and timestamp. | |
| 307 sequence += loop_count_ * rtp_seq_num_increase_; | |
| 308 timestamp += loop_count_ * rtp_timestamp_increase_; | |
| 309 // Write the updated sequence number and timestamp back to the RTP packet. | |
| 310 rtc::ByteBuffer buffer; | |
| 311 buffer.WriteUInt16(sequence); | |
| 312 buffer.WriteUInt32(timestamp); | |
| 313 memcpy(&packet->data[2], buffer.Data(), buffer.Length()); | |
| 314 } | |
| 315 } | |
| 316 | |
| 317 /////////////////////////////////////////////////////////////////////////// | |
| 318 // Implementation of RtpDumpWriter. | |
| 319 /////////////////////////////////////////////////////////////////////////// | |
| 320 | |
| 321 RtpDumpWriter::RtpDumpWriter(rtc::StreamInterface* stream) | |
| 322 : stream_(stream), | |
| 323 packet_filter_(PF_ALL), | |
| 324 file_header_written_(false), | |
| 325 start_time_ms_(rtc::Time()), | |
| 326 warn_slow_writes_delay_(kWarnSlowWritesDelayMs) { | |
| 327 } | |
| 328 | |
| 329 void RtpDumpWriter::set_packet_filter(int filter) { | |
| 330 packet_filter_ = filter; | |
| 331 LOG(LS_INFO) << "RtpDumpWriter set_packet_filter to " << packet_filter_; | |
| 332 } | |
| 333 | |
| 334 uint32_t RtpDumpWriter::GetElapsedTime() const { | |
| 335 return rtc::TimeSince(start_time_ms_); | |
| 336 } | |
| 337 | |
| 338 rtc::StreamResult RtpDumpWriter::WriteFileHeader() { | |
| 339 rtc::StreamResult res = WriteToStream( | |
| 340 RtpDumpFileHeader::kFirstLine, | |
| 341 strlen(RtpDumpFileHeader::kFirstLine)); | |
| 342 if (res != rtc::SR_SUCCESS) { | |
| 343 return res; | |
| 344 } | |
| 345 | |
| 346 rtc::ByteBuffer buf; | |
| 347 RtpDumpFileHeader file_header(rtc::Time(), 0, 0); | |
| 348 file_header.WriteToByteBuffer(&buf); | |
| 349 return WriteToStream(buf.Data(), buf.Length()); | |
| 350 } | |
| 351 | |
| 352 rtc::StreamResult RtpDumpWriter::WritePacket(const void* data, | |
| 353 size_t data_len, | |
| 354 uint32_t elapsed, | |
| 355 bool rtcp) { | |
| 356 if (!stream_ || !data || 0 == data_len) return rtc::SR_ERROR; | |
| 357 | |
| 358 rtc::StreamResult res = rtc::SR_SUCCESS; | |
| 359 // Write the file header if it has not been written yet. | |
| 360 if (!file_header_written_) { | |
| 361 res = WriteFileHeader(); | |
| 362 if (res != rtc::SR_SUCCESS) { | |
| 363 return res; | |
| 364 } | |
| 365 file_header_written_ = true; | |
| 366 } | |
| 367 | |
| 368 // Figure out what to write. | |
| 369 size_t write_len = FilterPacket(data, data_len, rtcp); | |
| 370 if (write_len == 0) { | |
| 371 return rtc::SR_SUCCESS; | |
| 372 } | |
| 373 | |
| 374 // Write the dump packet header. | |
| 375 rtc::ByteBuffer buf; | |
| 376 buf.WriteUInt16( | |
| 377 static_cast<uint16_t>(RtpDumpPacket::kHeaderLength + write_len)); | |
| 378 buf.WriteUInt16(static_cast<uint16_t>(rtcp ? 0 : data_len)); | |
| 379 buf.WriteUInt32(elapsed); | |
| 380 res = WriteToStream(buf.Data(), buf.Length()); | |
| 381 if (res != rtc::SR_SUCCESS) { | |
| 382 return res; | |
| 383 } | |
| 384 | |
| 385 // Write the header or full packet as indicated by write_len. | |
| 386 return WriteToStream(data, write_len); | |
| 387 } | |
| 388 | |
| 389 size_t RtpDumpWriter::FilterPacket(const void* data, size_t data_len, | |
| 390 bool rtcp) { | |
| 391 size_t filtered_len = 0; | |
| 392 if (!rtcp) { | |
| 393 if ((packet_filter_ & PF_RTPPACKET) == PF_RTPPACKET) { | |
| 394 // RTP header + payload | |
| 395 filtered_len = data_len; | |
| 396 } else if ((packet_filter_ & PF_RTPHEADER) == PF_RTPHEADER) { | |
| 397 // RTP header only | |
| 398 size_t header_len; | |
| 399 if (GetRtpHeaderLen(data, data_len, &header_len)) { | |
| 400 filtered_len = header_len; | |
| 401 } | |
| 402 } | |
| 403 } else { | |
| 404 if ((packet_filter_ & PF_RTCPPACKET) == PF_RTCPPACKET) { | |
| 405 // RTCP header + payload | |
| 406 filtered_len = data_len; | |
| 407 } | |
| 408 } | |
| 409 | |
| 410 return filtered_len; | |
| 411 } | |
| 412 | |
| 413 rtc::StreamResult RtpDumpWriter::WriteToStream( | |
| 414 const void* data, size_t data_len) { | |
| 415 uint32_t before = rtc::Time(); | |
| 416 rtc::StreamResult result = | |
| 417 stream_->WriteAll(data, data_len, NULL, NULL); | |
| 418 uint32_t delay = rtc::TimeSince(before); | |
| 419 if (delay >= warn_slow_writes_delay_) { | |
| 420 LOG(LS_WARNING) << "Slow RtpDump: took " << delay << "ms to write " | |
| 421 << data_len << " bytes."; | |
| 422 } | |
| 423 return result; | |
| 424 } | |
| 425 | |
| 426 } // namespace cricket | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1587193006:
Move talk/media to webrtc/media (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master