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 #ifndef TALK_MEDIA_BASE_RTPDUMP_H_ 29 #define TALK_MEDIA_BASE_RTPDUMP_H_ 30 31 #include <cstring> 32 #include <string> 33 #include <vector> 34 35 #include "talk/base/basictypes.h" 36 #include "talk/base/bytebuffer.h" 37 #include "talk/base/stream.h" 38 39 namespace cricket { 40 41 // We use the RTP dump file format compatible to the format used by rtptools 42 // (http://www.cs.columbia.edu/irt/software/rtptools/) and Wireshark 43 // (http://wiki.wireshark.org/rtpdump). In particular, the file starts with the 44 // first line "#!rtpplay1.0 address/port\n", followed by a 16 byte file header. 45 // For each packet, the file contains a 8 byte dump packet header, followed by 46 // the actual RTP or RTCP packet. 47 48 enum RtpDumpPacketFilter { 49 PF_NONE = 0x0, 50 PF_RTPHEADER = 0x1, 51 PF_RTPPACKET = 0x3, // includes header 52 // PF_RTCPHEADER = 0x4, // TODO(juberti) 53 PF_RTCPPACKET = 0xC, // includes header 54 PF_ALL = 0xF 55 }; 56 57 struct RtpDumpFileHeader { 58 RtpDumpFileHeader(uint32 start_ms, uint32 s, uint16 p); 59 void WriteToByteBuffer(talk_base::ByteBuffer* buf); 60 61 static const char kFirstLine[]; 62 static const size_t kHeaderLength = 16; 63 uint32 start_sec; // start of recording, the seconds part. 64 uint32 start_usec; // start of recording, the microseconds part. 65 uint32 source; // network source (multicast address). 66 uint16 port; // UDP port. 67 uint16 padding; // 2 bytes padding. 68 }; 69 70 struct RtpDumpPacket { 71 RtpDumpPacket() {} 72 73 RtpDumpPacket(const void* d, size_t s, uint32 elapsed, bool rtcp) 74 : elapsed_time(elapsed), 75 original_data_len((rtcp) ? 0 : s) { 76 data.resize(s); 77 memcpy(&data[0], d, s); 78 } 79 80 // In the rtpdump file format, RTCP packets have their data len set to zero, 81 // since RTCP has an internal length field. 82 bool is_rtcp() const { return original_data_len == 0; } 83 bool IsValidRtpPacket() const; 84 bool IsValidRtcpPacket() const; 85 // Get the payload type, sequence number, timestampe, and SSRC of the RTP 86 // packet. Return true and set the output parameter if successful. 87 bool GetRtpPayloadType(int* pt) const; 88 bool GetRtpSeqNum(int* seq_num) const; 89 bool GetRtpTimestamp(uint32* ts) const; 90 bool GetRtpSsrc(uint32* ssrc) const; 91 bool GetRtpHeaderLen(size_t* len) const; 92 // Get the type of the RTCP packet. Return true and set the output parameter 93 // if successful. 94 bool GetRtcpType(int* type) const; 95 96 static const size_t kHeaderLength = 8; 97 uint32 elapsed_time; // Milliseconds since the start of recording. 98 std::vector<uint8> data; // The actual RTP or RTCP packet. 99 size_t original_data_len; // The original length of the packet; may be 100 // greater than data.size() if only part of the 101 // packet was recorded. 102 }; 103 104 class RtpDumpReader { 105 public: 106 explicit RtpDumpReader(talk_base::StreamInterface* stream) 107 : stream_(stream), 108 file_header_read_(false), 109 first_line_and_file_header_len_(0), 110 start_time_ms_(0), 111 ssrc_override_(0) { 112 } 113 virtual ~RtpDumpReader() {} 114 115 // Use the specified ssrc, rather than the ssrc from dump, for RTP packets. 116 void SetSsrc(uint32 ssrc); 117 virtual talk_base::StreamResult ReadPacket(RtpDumpPacket* packet); 118 119 protected: 120 talk_base::StreamResult ReadFileHeader(); 121 bool RewindToFirstDumpPacket() { 122 return stream_->SetPosition(first_line_and_file_header_len_); 123 } 124 125 private: 126 // Check if its matches "#!rtpplay1.0 address/port\n". 127 bool CheckFirstLine(const std::string& first_line); 128 129 talk_base::StreamInterface* stream_; 130 bool file_header_read_; 131 size_t first_line_and_file_header_len_; 132 uint32 start_time_ms_; 133 uint32 ssrc_override_; 134 135 DISALLOW_COPY_AND_ASSIGN(RtpDumpReader); 136 }; 137 138 // RtpDumpLoopReader reads RTP dump packets from the input stream and rewinds 139 // the stream when it ends. RtpDumpLoopReader maintains the elapsed time, the 140 // RTP sequence number and the RTP timestamp properly. RtpDumpLoopReader can 141 // handle both RTP dump and RTCP dump. We assume that the dump does not mix 142 // RTP packets and RTCP packets. 143 class RtpDumpLoopReader : public RtpDumpReader { 144 public: 145 explicit RtpDumpLoopReader(talk_base::StreamInterface* stream); 146 virtual talk_base::StreamResult ReadPacket(RtpDumpPacket* packet); 147 148 private: 149 // During the first loop, update the statistics, including packet count, frame 150 // count, timestamps, and sequence number, of the input stream. 151 void UpdateStreamStatistics(const RtpDumpPacket& packet); 152 153 // At the end of first loop, calculate elapsed_time_increases_, 154 // rtp_seq_num_increase_, and rtp_timestamp_increase_. 155 void CalculateIncreases(); 156 157 // During the second and later loops, update the elapsed time of the dump 158 // packet. If the dumped packet is a RTP packet, update its RTP sequence 159 // number and timestamp as well. 160 void UpdateDumpPacket(RtpDumpPacket* packet); 161 162 int loop_count_; 163 // How much to increase the elapsed time, RTP sequence number, RTP timestampe 164 // for each loop. They are calcualted with the variables below during the 165 // first loop. 166 uint32 elapsed_time_increases_; 167 int rtp_seq_num_increase_; 168 uint32 rtp_timestamp_increase_; 169 // How many RTP packets and how many payload frames in the input stream. RTP 170 // packets belong to the same frame have the same RTP timestamp, different 171 // dump timestamp, and different RTP sequence number. 172 uint32 packet_count_; 173 uint32 frame_count_; 174 // The elapsed time, RTP sequence number, and RTP timestamp of the first and 175 // the previous dump packets in the input stream. 176 uint32 first_elapsed_time_; 177 int first_rtp_seq_num_; 178 uint32 first_rtp_timestamp_; 179 uint32 prev_elapsed_time_; 180 int prev_rtp_seq_num_; 181 uint32 prev_rtp_timestamp_; 182 183 DISALLOW_COPY_AND_ASSIGN(RtpDumpLoopReader); 184 }; 185 186 class RtpDumpWriter { 187 public: 188 explicit RtpDumpWriter(talk_base::StreamInterface* stream); 189 190 // Filter to control what packets we actually record. 191 void set_packet_filter(int filter); 192 // Write a RTP or RTCP packet. The parameters data points to the packet and 193 // data_len is its length. 194 talk_base::StreamResult WriteRtpPacket(const void* data, size_t data_len) { 195 return WritePacket(data, data_len, GetElapsedTime(), false); 196 } 197 talk_base::StreamResult WriteRtcpPacket(const void* data, size_t data_len) { 198 return WritePacket(data, data_len, GetElapsedTime(), true); 199 } 200 talk_base::StreamResult WritePacket(const RtpDumpPacket& packet) { 201 return WritePacket(&packet.data[0], packet.data.size(), packet.elapsed_time, 202 packet.is_rtcp()); 203 } 204 uint32 GetElapsedTime() const; 205 206 bool GetDumpSize(size_t* size) { 207 // Note that we use GetPosition(), rather than GetSize(), to avoid flush the 208 // stream per write. 209 return stream_ && size && stream_->GetPosition(size); 210 } 211 212 protected: 213 talk_base::StreamResult WriteFileHeader(); 214 215 private: 216 talk_base::StreamResult WritePacket(const void* data, size_t data_len, 217 uint32 elapsed, bool rtcp); 218 size_t FilterPacket(const void* data, size_t data_len, bool rtcp); 219 talk_base::StreamResult WriteToStream(const void* data, size_t data_len); 220 221 talk_base::StreamInterface* stream_; 222 int packet_filter_; 223 bool file_header_written_; 224 uint32 start_time_ms_; // Time when the record starts. 225 // If writing to the stream takes longer than this many ms, log a warning. 226 uint32 warn_slow_writes_delay_; 227 DISALLOW_COPY_AND_ASSIGN(RtpDumpWriter); 228 }; 229 230 } // namespace cricket 231 232 #endif // TALK_MEDIA_BASE_RTPDUMP_H_ 233
