henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 1 | /* |
kjellander | 1afca73 | 2016-02-08 04:46:45 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 3 | * |
kjellander | 1afca73 | 2016-02-08 04:46:45 | [diff] [blame] | 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 |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 11 | #include "media/base/rtpdataengine.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 12 | |
Steve Anton | e78bcb9 | 2017-10-31 16:53:08 | [diff] [blame] | 13 | #include <map> |
| 14 | |
Niels Möller | 3c7d599 | 2018-10-19 13:29:54 | [diff] [blame] | 15 | #include "absl/strings/match.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 16 | #include "media/base/codec.h" |
| 17 | #include "media/base/mediaconstants.h" |
| 18 | #include "media/base/rtputils.h" |
| 19 | #include "media/base/streamparams.h" |
| 20 | #include "rtc_base/copyonwritebuffer.h" |
Sebastian Jansson | f9c5cf6 | 2018-02-28 15:04:26 | [diff] [blame] | 21 | #include "rtc_base/data_rate_limiter.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 22 | #include "rtc_base/helpers.h" |
| 23 | #include "rtc_base/logging.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 24 | #include "rtc_base/sanitizer.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 25 | |
| 26 | namespace cricket { |
| 27 | |
| 28 | // We want to avoid IP fragmentation. |
| 29 | static const size_t kDataMaxRtpPacketLen = 1200U; |
| 30 | // We reserve space after the RTP header for future wiggle room. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 31 | static const unsigned char kReservedSpace[] = {0x00, 0x00, 0x00, 0x00}; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 32 | |
| 33 | // Amount of overhead SRTP may take. We need to leave room in the |
| 34 | // buffer for it, otherwise SRTP will fail later. If SRTP ever uses |
| 35 | // more than this, we need to increase this number. |
| 36 | static const size_t kMaxSrtpHmacOverhead = 16; |
| 37 | |
| 38 | RtpDataEngine::RtpDataEngine() { |
| 39 | data_codecs_.push_back( |
solenberg | 9fa4975 | 2016-10-08 20:02:44 | [diff] [blame] | 40 | DataCodec(kGoogleRtpDataCodecPlType, kGoogleRtpDataCodecName)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 41 | } |
| 42 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 43 | DataMediaChannel* RtpDataEngine::CreateChannel(const MediaConfig& config) { |
zhihuang | ebbe4f2 | 2016-12-06 18:45:42 | [diff] [blame] | 44 | return new RtpDataMediaChannel(config); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 45 | } |
| 46 | |
magjed | b49fc14 | 2016-11-30 12:52:04 | [diff] [blame] | 47 | static const DataCodec* FindCodecByName(const std::vector<DataCodec>& codecs, |
| 48 | const std::string& name) { |
| 49 | for (const DataCodec& codec : codecs) { |
Niels Möller | 3c7d599 | 2018-10-19 13:29:54 | [diff] [blame] | 50 | if (absl::EqualsIgnoreCase(name, codec.name)) |
magjed | b49fc14 | 2016-11-30 12:52:04 | [diff] [blame] | 51 | return &codec; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 52 | } |
magjed | b49fc14 | 2016-11-30 12:52:04 | [diff] [blame] | 53 | return nullptr; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 54 | } |
| 55 | |
zhihuang | ebbe4f2 | 2016-12-06 18:45:42 | [diff] [blame] | 56 | RtpDataMediaChannel::RtpDataMediaChannel(const MediaConfig& config) |
| 57 | : DataMediaChannel(config) { |
nisse | cdf37a9 | 2016-09-14 06:41:47 | [diff] [blame] | 58 | Construct(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 59 | } |
| 60 | |
nisse | cdf37a9 | 2016-09-14 06:41:47 | [diff] [blame] | 61 | void RtpDataMediaChannel::Construct() { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 62 | sending_ = false; |
| 63 | receiving_ = false; |
Sebastian Jansson | f9c5cf6 | 2018-02-28 15:04:26 | [diff] [blame] | 64 | send_limiter_.reset(new rtc::DataRateLimiter(kDataMaxBandwidth / 8, 1.0)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 65 | } |
| 66 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 67 | RtpDataMediaChannel::~RtpDataMediaChannel() { |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 68 | std::map<uint32_t, RtpClock*>::const_iterator iter; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 69 | for (iter = rtp_clock_by_send_ssrc_.begin(); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 70 | iter != rtp_clock_by_send_ssrc_.end(); ++iter) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 71 | delete iter->second; |
| 72 | } |
| 73 | } |
| 74 | |
oprypin | 30431d5 | 2017-09-05 16:49:30 | [diff] [blame] | 75 | void RTC_NO_SANITIZE("float-cast-overflow") // bugs.webrtc.org/8204 |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 76 | RtpClock::Tick(double now, int* seq_num, uint32_t* timestamp) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 77 | *seq_num = ++last_seq_num_; |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 78 | *timestamp = timestamp_offset_ + static_cast<uint32_t>(now * clockrate_); |
oprypin | 30431d5 | 2017-09-05 16:49:30 | [diff] [blame] | 79 | // UBSan: 5.92374e+10 is outside the range of representable values of type |
| 80 | // 'unsigned int' |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | const DataCodec* FindUnknownCodec(const std::vector<DataCodec>& codecs) { |
solenberg | 9fa4975 | 2016-10-08 20:02:44 | [diff] [blame] | 84 | DataCodec data_codec(kGoogleRtpDataCodecPlType, kGoogleRtpDataCodecName); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 85 | std::vector<DataCodec>::const_iterator iter; |
| 86 | for (iter = codecs.begin(); iter != codecs.end(); ++iter) { |
| 87 | if (!iter->Matches(data_codec)) { |
| 88 | return &(*iter); |
| 89 | } |
| 90 | } |
| 91 | return NULL; |
| 92 | } |
| 93 | |
| 94 | const DataCodec* FindKnownCodec(const std::vector<DataCodec>& codecs) { |
solenberg | 9fa4975 | 2016-10-08 20:02:44 | [diff] [blame] | 95 | DataCodec data_codec(kGoogleRtpDataCodecPlType, kGoogleRtpDataCodecName); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 96 | std::vector<DataCodec>::const_iterator iter; |
| 97 | for (iter = codecs.begin(); iter != codecs.end(); ++iter) { |
| 98 | if (iter->Matches(data_codec)) { |
| 99 | return &(*iter); |
| 100 | } |
| 101 | } |
| 102 | return NULL; |
| 103 | } |
| 104 | |
| 105 | bool RtpDataMediaChannel::SetRecvCodecs(const std::vector<DataCodec>& codecs) { |
| 106 | const DataCodec* unknown_codec = FindUnknownCodec(codecs); |
| 107 | if (unknown_codec) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 108 | RTC_LOG(LS_WARNING) << "Failed to SetRecvCodecs because of unknown codec: " |
| 109 | << unknown_codec->ToString(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 110 | return false; |
| 111 | } |
| 112 | |
| 113 | recv_codecs_ = codecs; |
| 114 | return true; |
| 115 | } |
| 116 | |
| 117 | bool RtpDataMediaChannel::SetSendCodecs(const std::vector<DataCodec>& codecs) { |
| 118 | const DataCodec* known_codec = FindKnownCodec(codecs); |
| 119 | if (!known_codec) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 120 | RTC_LOG(LS_WARNING) |
| 121 | << "Failed to SetSendCodecs because there is no known codec."; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 122 | return false; |
| 123 | } |
| 124 | |
| 125 | send_codecs_ = codecs; |
| 126 | return true; |
| 127 | } |
| 128 | |
Fredrik Solenberg | b071a19 | 2015-09-17 14:42:56 | [diff] [blame] | 129 | bool RtpDataMediaChannel::SetSendParameters(const DataSendParameters& params) { |
| 130 | return (SetSendCodecs(params.codecs) && |
| 131 | SetMaxSendBandwidth(params.max_bandwidth_bps)); |
| 132 | } |
| 133 | |
| 134 | bool RtpDataMediaChannel::SetRecvParameters(const DataRecvParameters& params) { |
| 135 | return SetRecvCodecs(params.codecs); |
| 136 | } |
| 137 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 138 | bool RtpDataMediaChannel::AddSendStream(const StreamParams& stream) { |
| 139 | if (!stream.has_ssrcs()) { |
| 140 | return false; |
| 141 | } |
| 142 | |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 | [diff] [blame] | 143 | if (GetStreamBySsrc(send_streams_, stream.first_ssrc())) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 144 | RTC_LOG(LS_WARNING) << "Not adding data send stream '" << stream.id |
| 145 | << "' with ssrc=" << stream.first_ssrc() |
| 146 | << " because stream already exists."; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 147 | return false; |
| 148 | } |
| 149 | |
| 150 | send_streams_.push_back(stream); |
| 151 | // TODO(pthatcher): This should be per-stream, not per-ssrc. |
| 152 | // And we should probably allow more than one per stream. |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 153 | rtp_clock_by_send_ssrc_[stream.first_ssrc()] = |
| 154 | new RtpClock(kDataCodecClockrate, rtc::CreateRandomNonZeroId(), |
| 155 | rtc::CreateRandomNonZeroId()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 156 | |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 157 | RTC_LOG(LS_INFO) << "Added data send stream '" << stream.id |
| 158 | << "' with ssrc=" << stream.first_ssrc(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 159 | return true; |
| 160 | } |
| 161 | |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 162 | bool RtpDataMediaChannel::RemoveSendStream(uint32_t ssrc) { |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 | [diff] [blame] | 163 | if (!GetStreamBySsrc(send_streams_, ssrc)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 164 | return false; |
| 165 | } |
| 166 | |
| 167 | RemoveStreamBySsrc(&send_streams_, ssrc); |
| 168 | delete rtp_clock_by_send_ssrc_[ssrc]; |
| 169 | rtp_clock_by_send_ssrc_.erase(ssrc); |
| 170 | return true; |
| 171 | } |
| 172 | |
| 173 | bool RtpDataMediaChannel::AddRecvStream(const StreamParams& stream) { |
| 174 | if (!stream.has_ssrcs()) { |
| 175 | return false; |
| 176 | } |
| 177 | |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 | [diff] [blame] | 178 | if (GetStreamBySsrc(recv_streams_, stream.first_ssrc())) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 179 | RTC_LOG(LS_WARNING) << "Not adding data recv stream '" << stream.id |
| 180 | << "' with ssrc=" << stream.first_ssrc() |
| 181 | << " because stream already exists."; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 182 | return false; |
| 183 | } |
| 184 | |
| 185 | recv_streams_.push_back(stream); |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 186 | RTC_LOG(LS_INFO) << "Added data recv stream '" << stream.id |
| 187 | << "' with ssrc=" << stream.first_ssrc(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 188 | return true; |
| 189 | } |
| 190 | |
Peter Boström | 0c4e06b | 2015-10-07 10:23:21 | [diff] [blame] | 191 | bool RtpDataMediaChannel::RemoveRecvStream(uint32_t ssrc) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 192 | RemoveStreamBySsrc(&recv_streams_, ssrc); |
| 193 | return true; |
| 194 | } |
| 195 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 196 | void RtpDataMediaChannel::OnPacketReceived(rtc::CopyOnWriteBuffer* packet, |
| 197 | const rtc::PacketTime& packet_time) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 198 | RtpHeader header; |
jbauch | eec21bd | 2016-03-20 13:15:43 | [diff] [blame] | 199 | if (!GetRtpHeader(packet->cdata(), packet->size(), &header)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 200 | return; |
| 201 | } |
| 202 | |
| 203 | size_t header_length; |
jbauch | eec21bd | 2016-03-20 13:15:43 | [diff] [blame] | 204 | if (!GetRtpHeaderLen(packet->cdata(), packet->size(), &header_length)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 205 | return; |
| 206 | } |
Karl Wiberg | 9478437 | 2015-04-20 12:03:07 | [diff] [blame] | 207 | const char* data = |
jbauch | eec21bd | 2016-03-20 13:15:43 | [diff] [blame] | 208 | packet->cdata<char>() + header_length + sizeof(kReservedSpace); |
kwiberg@webrtc.org | eebcab5 | 2015-03-24 09:19:06 | [diff] [blame] | 209 | size_t data_len = packet->size() - header_length - sizeof(kReservedSpace); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 210 | |
| 211 | if (!receiving_) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 212 | RTC_LOG(LS_WARNING) << "Not receiving packet " << header.ssrc << ":" |
| 213 | << header.seq_num << " before SetReceive(true) called."; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 214 | return; |
| 215 | } |
| 216 | |
magjed | b05fa24 | 2016-11-11 12:00:16 | [diff] [blame] | 217 | if (!FindCodecById(recv_codecs_, header.payload_type)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 218 | return; |
| 219 | } |
| 220 | |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 | [diff] [blame] | 221 | if (!GetStreamBySsrc(recv_streams_, header.ssrc)) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 222 | RTC_LOG(LS_WARNING) << "Received packet for unknown ssrc: " << header.ssrc; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 223 | return; |
| 224 | } |
| 225 | |
| 226 | // Uncomment this for easy debugging. |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 | [diff] [blame] | 227 | // const auto* found_stream = GetStreamBySsrc(recv_streams_, header.ssrc); |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 228 | // RTC_LOG(LS_INFO) << "Received packet" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 229 | // << " groupid=" << found_stream.groupid |
| 230 | // << ", ssrc=" << header.ssrc |
| 231 | // << ", seqnum=" << header.seq_num |
| 232 | // << ", timestamp=" << header.timestamp |
| 233 | // << ", len=" << data_len; |
| 234 | |
| 235 | ReceiveDataParams params; |
| 236 | params.ssrc = header.ssrc; |
| 237 | params.seq_num = header.seq_num; |
| 238 | params.timestamp = header.timestamp; |
| 239 | SignalDataReceived(params, data, data_len); |
| 240 | } |
| 241 | |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 | [diff] [blame] | 242 | bool RtpDataMediaChannel::SetMaxSendBandwidth(int bps) { |
| 243 | if (bps <= 0) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 244 | bps = kDataMaxBandwidth; |
| 245 | } |
Sebastian Jansson | f9c5cf6 | 2018-02-28 15:04:26 | [diff] [blame] | 246 | send_limiter_.reset(new rtc::DataRateLimiter(bps / 8, 1.0)); |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 247 | RTC_LOG(LS_INFO) << "RtpDataMediaChannel::SetSendBandwidth to " << bps |
| 248 | << "bps."; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 249 | return true; |
| 250 | } |
| 251 | |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 252 | bool RtpDataMediaChannel::SendData(const SendDataParams& params, |
| 253 | const rtc::CopyOnWriteBuffer& payload, |
| 254 | SendDataResult* result) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 255 | if (result) { |
| 256 | // If we return true, we'll set this to SDR_SUCCESS. |
| 257 | *result = SDR_ERROR; |
| 258 | } |
| 259 | if (!sending_) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 260 | RTC_LOG(LS_WARNING) << "Not sending packet with ssrc=" << params.ssrc |
| 261 | << " len=" << payload.size() |
| 262 | << " before SetSend(true)."; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 263 | return false; |
| 264 | } |
| 265 | |
| 266 | if (params.type != cricket::DMT_TEXT) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 267 | RTC_LOG(LS_WARNING) |
| 268 | << "Not sending data because binary type is unsupported."; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 269 | return false; |
| 270 | } |
| 271 | |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 | [diff] [blame] | 272 | const StreamParams* found_stream = |
| 273 | GetStreamBySsrc(send_streams_, params.ssrc); |
| 274 | if (!found_stream) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 275 | RTC_LOG(LS_WARNING) << "Not sending data because ssrc is unknown: " |
| 276 | << params.ssrc; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 277 | return false; |
| 278 | } |
| 279 | |
magjed | b49fc14 | 2016-11-30 12:52:04 | [diff] [blame] | 280 | const DataCodec* found_codec = |
| 281 | FindCodecByName(send_codecs_, kGoogleRtpDataCodecName); |
| 282 | if (!found_codec) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 283 | RTC_LOG(LS_WARNING) << "Not sending data because codec is unknown: " |
| 284 | << kGoogleRtpDataCodecName; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 285 | return false; |
| 286 | } |
| 287 | |
kwiberg@webrtc.org | eebcab5 | 2015-03-24 09:19:06 | [diff] [blame] | 288 | size_t packet_len = (kMinRtpPacketLen + sizeof(kReservedSpace) + |
| 289 | payload.size() + kMaxSrtpHmacOverhead); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 290 | if (packet_len > kDataMaxRtpPacketLen) { |
| 291 | return false; |
| 292 | } |
| 293 | |
nisse | cdf37a9 | 2016-09-14 06:41:47 | [diff] [blame] | 294 | double now = |
| 295 | rtc::TimeMicros() / static_cast<double>(rtc::kNumMicrosecsPerSec); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 296 | |
| 297 | if (!send_limiter_->CanUse(packet_len, now)) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 298 | RTC_LOG(LS_VERBOSE) << "Dropped data packet of len=" << packet_len |
| 299 | << "; already sent " << send_limiter_->used_in_period() |
| 300 | << "/" << send_limiter_->max_per_period(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 301 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 302 | } |
| 303 | |
| 304 | RtpHeader header; |
magjed | b49fc14 | 2016-11-30 12:52:04 | [diff] [blame] | 305 | header.payload_type = found_codec->id; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 306 | header.ssrc = params.ssrc; |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 307 | rtp_clock_by_send_ssrc_[header.ssrc]->Tick(now, &header.seq_num, |
| 308 | &header.timestamp); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 309 | |
jbauch | eec21bd | 2016-03-20 13:15:43 | [diff] [blame] | 310 | rtc::CopyOnWriteBuffer packet(kMinRtpPacketLen, packet_len); |
kwiberg@webrtc.org | eebcab5 | 2015-03-24 09:19:06 | [diff] [blame] | 311 | if (!SetRtpHeader(packet.data(), packet.size(), header)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 312 | return false; |
| 313 | } |
Karl Wiberg | 9478437 | 2015-04-20 12:03:07 | [diff] [blame] | 314 | packet.AppendData(kReservedSpace); |
| 315 | packet.AppendData(payload); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 316 | |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 317 | RTC_LOG(LS_VERBOSE) << "Sent RTP data packet: " |
| 318 | << " stream=" << found_stream->id |
| 319 | << " ssrc=" << header.ssrc |
| 320 | << ", seqnum=" << header.seq_num |
| 321 | << ", timestamp=" << header.timestamp |
| 322 | << ", len=" << payload.size(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 323 | |
Qingsi Wang | 6e641e6 | 2018-04-12 03:14:17 | [diff] [blame] | 324 | rtc::PacketOptions options; |
| 325 | options.info_signaled_after_sent.packet_type = rtc::PacketType::kData; |
| 326 | MediaChannel::SendPacket(&packet, options); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 327 | send_limiter_->Use(packet_len, now); |
| 328 | if (result) { |
| 329 | *result = SDR_SUCCESS; |
| 330 | } |
| 331 | return true; |
| 332 | } |
| 333 | |
zhihuang | ebbe4f2 | 2016-12-06 18:45:42 | [diff] [blame] | 334 | rtc::DiffServCodePoint RtpDataMediaChannel::PreferredDscp() const { |
| 335 | return rtc::DSCP_AF41; |
| 336 | } |
| 337 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 | [diff] [blame] | 338 | } // namespace cricket |