OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 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 164 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
175 EXPECT_EQ(payload_, rtp_header.payloadType); | 175 EXPECT_EQ(payload_, rtp_header.payloadType); |
176 EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber); | 176 EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber); |
177 EXPECT_EQ(kTimestamp, rtp_header.timestamp); | 177 EXPECT_EQ(kTimestamp, rtp_header.timestamp); |
178 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc); | 178 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc); |
179 EXPECT_EQ(number_of_csrcs, rtp_header.numCSRCs); | 179 EXPECT_EQ(number_of_csrcs, rtp_header.numCSRCs); |
180 EXPECT_EQ(0U, rtp_header.paddingLength); | 180 EXPECT_EQ(0U, rtp_header.paddingLength); |
181 } | 181 } |
182 | 182 |
183 void SendPacket(int64_t capture_time_ms, int payload_length) { | 183 void SendPacket(int64_t capture_time_ms, int payload_length) { |
184 uint32_t timestamp = capture_time_ms * 90; | 184 uint32_t timestamp = capture_time_ms * 90; |
185 int32_t rtp_length = rtp_sender_->BuildRTPheader( | 185 int32_t rtp_length = rtp_sender_->BuildRtpHeader( |
186 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms); | 186 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms); |
187 ASSERT_GE(rtp_length, 0); | 187 ASSERT_GE(rtp_length, 0); |
188 | 188 |
189 // Packet should be stored in a send bucket. | 189 // Packet should be stored in a send bucket. |
190 EXPECT_EQ(0, rtp_sender_->SendToNetwork( | 190 EXPECT_EQ(0, rtp_sender_->SendToNetwork( |
191 packet_, payload_length, rtp_length, capture_time_ms, | 191 packet_, payload_length, rtp_length, capture_time_ms, |
192 kAllowRetransmission, RtpPacketSender::kNormalPriority)); | 192 kAllowRetransmission, RtpPacketSender::kNormalPriority)); |
193 } | 193 } |
194 | 194 |
195 void SendGenericPayload() { | 195 void SendGenericPayload() { |
196 const uint8_t kPayload[] = {47, 11, 32, 93, 89}; | 196 const uint8_t kPayload[] = {47, 11, 32, 93, 89}; |
197 const uint32_t kTimestamp = 1234; | 197 const uint32_t kTimestamp = 1234; |
198 const uint8_t kPayloadType = 127; | 198 const uint8_t kPayloadType = 127; |
199 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); | 199 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); |
200 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; | 200 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; |
201 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, | 201 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, |
202 0, 1500)); | 202 0, 1500)); |
203 | 203 |
204 EXPECT_EQ(0, rtp_sender_->SendOutgoingData( | 204 EXPECT_EQ(0, rtp_sender_->SendOutgoingData( |
205 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, | 205 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, |
206 kPayload, sizeof(kPayload), nullptr)); | 206 kPayload, sizeof(kPayload), nullptr, nullptr)); |
207 } | 207 } |
208 }; | 208 }; |
209 | 209 |
210 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our | 210 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our |
211 // default code path. | 211 // default code path. |
212 class RtpSenderTestWithoutPacer : public RtpSenderTest { | 212 class RtpSenderTestWithoutPacer : public RtpSenderTest { |
213 public: | 213 public: |
214 void SetUp() override { SetUpRtpSender(false); } | 214 void SetUp() override { SetUpRtpSender(false); } |
215 }; | 215 }; |
216 | 216 |
217 class RtpSenderVideoTest : public RtpSenderTest { | 217 class RtpSenderVideoTest : public RtpSenderTest { |
218 protected: | 218 protected: |
219 void SetUp() override { | 219 void SetUp() override { |
220 // TODO(pbos): Set up to use pacer. | 220 // TODO(pbos): Set up to use pacer. |
221 SetUpRtpSender(false); | 221 SetUpRtpSender(false); |
222 rtp_sender_video_.reset( | 222 rtp_sender_video_.reset( |
223 new RTPSenderVideo(&fake_clock_, rtp_sender_.get())); | 223 new RTPSenderVideo(&fake_clock_, rtp_sender_.get())); |
224 } | 224 } |
225 std::unique_ptr<RTPSenderVideo> rtp_sender_video_; | 225 std::unique_ptr<RTPSenderVideo> rtp_sender_video_; |
226 | 226 |
227 void VerifyCVOPacket(uint8_t* data, | 227 void VerifyCVOPacket(uint8_t* data, |
228 size_t len, | 228 size_t len, |
229 bool expect_cvo, | 229 bool expect_cvo, |
230 RtpHeaderExtensionMap* map, | 230 RtpHeaderExtensionMap* map, |
231 uint16_t seq_num, | 231 uint16_t seq_num, |
232 VideoRotation rotation) { | 232 VideoRotation rotation) { |
233 webrtc::RtpUtility::RtpHeaderParser rtp_parser(data, len); | 233 webrtc::RtpUtility::RtpHeaderParser rtp_parser(data, len); |
234 | 234 |
235 webrtc::RTPHeader rtp_header; | 235 webrtc::RTPHeader rtp_header; |
236 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 236 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader( |
237 packet_, kPayload, expect_cvo /* marker_bit */, kTimestamp, 0)); | 237 packet_, kPayload, expect_cvo /* marker_bit */, kTimestamp, 0)); |
238 if (expect_cvo) { | 238 if (expect_cvo) { |
239 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), | 239 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), |
240 length); | 240 length); |
241 } else { | 241 } else { |
242 ASSERT_EQ(kRtpHeaderSize, length); | 242 ASSERT_EQ(kRtpHeaderSize, length); |
243 } | 243 } |
244 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, map)); | 244 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, map)); |
245 ASSERT_FALSE(rtp_parser.RTCP()); | 245 ASSERT_FALSE(rtp_parser.RTCP()); |
246 EXPECT_EQ(payload_, rtp_header.payloadType); | 246 EXPECT_EQ(payload_, rtp_header.payloadType); |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
353 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); | 353 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); |
354 EXPECT_EQ( | 354 EXPECT_EQ( |
355 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength), | 355 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength), |
356 rtp_sender_->RtpHeaderExtensionLength()); | 356 rtp_sender_->RtpHeaderExtensionLength()); |
357 EXPECT_EQ( | 357 EXPECT_EQ( |
358 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation)); | 358 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation)); |
359 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength()); | 359 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength()); |
360 } | 360 } |
361 | 361 |
362 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) { | 362 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) { |
363 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 363 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader( |
364 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 364 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
365 ASSERT_EQ(kRtpHeaderSize, length); | 365 ASSERT_EQ(kRtpHeaderSize, length); |
366 | 366 |
367 // Verify | 367 // Verify |
368 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 368 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
369 webrtc::RTPHeader rtp_header; | 369 webrtc::RTPHeader rtp_header; |
370 | 370 |
371 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr); | 371 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr); |
372 | 372 |
373 ASSERT_TRUE(valid_rtp_header); | 373 ASSERT_TRUE(valid_rtp_header); |
(...skipping 10 matching lines...) Expand all Loading... |
384 EXPECT_EQ(0u, rtp_header.extension.videoRotation); | 384 EXPECT_EQ(0u, rtp_header.extension.videoRotation); |
385 } | 385 } |
386 | 386 |
387 TEST_F(RtpSenderTestWithoutPacer, | 387 TEST_F(RtpSenderTestWithoutPacer, |
388 BuildRTPPacketWithTransmissionOffsetExtension) { | 388 BuildRTPPacketWithTransmissionOffsetExtension) { |
389 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset)); | 389 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset)); |
390 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 390 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
391 kRtpExtensionTransmissionTimeOffset, | 391 kRtpExtensionTransmissionTimeOffset, |
392 kTransmissionTimeOffsetExtensionId)); | 392 kTransmissionTimeOffsetExtensionId)); |
393 | 393 |
394 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 394 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader( |
395 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 395 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
396 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); | 396 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); |
397 | 397 |
398 // Verify | 398 // Verify |
399 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 399 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
400 webrtc::RTPHeader rtp_header; | 400 webrtc::RTPHeader rtp_header; |
401 | 401 |
402 RtpHeaderExtensionMap map; | 402 RtpHeaderExtensionMap map; |
403 map.Register(kRtpExtensionTransmissionTimeOffset, | 403 map.Register(kRtpExtensionTransmissionTimeOffset, |
404 kTransmissionTimeOffsetExtensionId); | 404 kTransmissionTimeOffsetExtensionId); |
(...skipping 18 matching lines...) Expand all Loading... |
423 } | 423 } |
424 | 424 |
425 TEST_F(RtpSenderTestWithoutPacer, | 425 TEST_F(RtpSenderTestWithoutPacer, |
426 BuildRTPPacketWithNegativeTransmissionOffsetExtension) { | 426 BuildRTPPacketWithNegativeTransmissionOffsetExtension) { |
427 const int kNegTimeOffset = -500; | 427 const int kNegTimeOffset = -500; |
428 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset)); | 428 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset)); |
429 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 429 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
430 kRtpExtensionTransmissionTimeOffset, | 430 kRtpExtensionTransmissionTimeOffset, |
431 kTransmissionTimeOffsetExtensionId)); | 431 kTransmissionTimeOffsetExtensionId)); |
432 | 432 |
433 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 433 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader( |
434 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 434 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
435 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); | 435 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); |
436 | 436 |
437 // Verify | 437 // Verify |
438 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 438 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
439 webrtc::RTPHeader rtp_header; | 439 webrtc::RTPHeader rtp_header; |
440 | 440 |
441 RtpHeaderExtensionMap map; | 441 RtpHeaderExtensionMap map; |
442 map.Register(kRtpExtensionTransmissionTimeOffset, | 442 map.Register(kRtpExtensionTransmissionTimeOffset, |
443 kTransmissionTimeOffsetExtensionId); | 443 kTransmissionTimeOffsetExtensionId); |
444 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map); | 444 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map); |
445 | 445 |
446 ASSERT_TRUE(valid_rtp_header); | 446 ASSERT_TRUE(valid_rtp_header); |
447 ASSERT_FALSE(rtp_parser.RTCP()); | 447 ASSERT_FALSE(rtp_parser.RTCP()); |
448 VerifyRTPHeaderCommon(rtp_header); | 448 VerifyRTPHeaderCommon(rtp_header); |
449 EXPECT_EQ(length, rtp_header.headerLength); | 449 EXPECT_EQ(length, rtp_header.headerLength); |
450 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset); | 450 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset); |
451 EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset); | 451 EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset); |
452 } | 452 } |
453 | 453 |
454 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) { | 454 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) { |
455 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime)); | 455 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime)); |
456 EXPECT_EQ( | 456 EXPECT_EQ( |
457 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 457 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, |
458 kAbsoluteSendTimeExtensionId)); | 458 kAbsoluteSendTimeExtensionId)); |
459 | 459 |
460 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 460 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader( |
461 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 461 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
462 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); | 462 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); |
463 | 463 |
464 // Verify | 464 // Verify |
465 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 465 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
466 webrtc::RTPHeader rtp_header; | 466 webrtc::RTPHeader rtp_header; |
467 | 467 |
468 RtpHeaderExtensionMap map; | 468 RtpHeaderExtensionMap map; |
469 map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId); | 469 map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId); |
470 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map); | 470 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map); |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
535 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) { | 535 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) { |
536 rtp_sender_->SetVideoRotation(kRotation); | 536 rtp_sender_->SetVideoRotation(kRotation); |
537 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 537 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
538 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); | 538 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); |
539 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); | 539 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); |
540 | 540 |
541 RtpHeaderExtensionMap map; | 541 RtpHeaderExtensionMap map; |
542 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); | 542 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); |
543 | 543 |
544 size_t length = static_cast<size_t>( | 544 size_t length = static_cast<size_t>( |
545 rtp_sender_->BuildRTPheader(packet_, kPayload, true, kTimestamp, 0)); | 545 rtp_sender_->BuildRtpHeader(packet_, kPayload, true, kTimestamp, 0)); |
546 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); | 546 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); |
547 | 547 |
548 // Verify | 548 // Verify |
549 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 549 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
550 webrtc::RTPHeader rtp_header; | 550 webrtc::RTPHeader rtp_header; |
551 | 551 |
552 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map)); | 552 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map)); |
553 ASSERT_FALSE(rtp_parser.RTCP()); | 553 ASSERT_FALSE(rtp_parser.RTCP()); |
554 VerifyRTPHeaderCommon(rtp_header); | 554 VerifyRTPHeaderCommon(rtp_header); |
555 EXPECT_EQ(length, rtp_header.headerLength); | 555 EXPECT_EQ(length, rtp_header.headerLength); |
556 EXPECT_TRUE(rtp_header.extension.hasVideoRotation); | 556 EXPECT_TRUE(rtp_header.extension.hasVideoRotation); |
557 EXPECT_EQ(ConvertVideoRotationToCVOByte(kRotation), | 557 EXPECT_EQ(ConvertVideoRotationToCVOByte(kRotation), |
558 rtp_header.extension.videoRotation); | 558 rtp_header.extension.videoRotation); |
559 } | 559 } |
560 | 560 |
561 // Test CVO header extension is not set when marker bit is false. | 561 // Test CVO header extension is not set when marker bit is false. |
562 TEST_F(RtpSenderTestWithoutPacer, | 562 TEST_F(RtpSenderTestWithoutPacer, |
563 DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) { | 563 DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) { |
564 rtp_sender_->SetVideoRotation(kRotation); | 564 rtp_sender_->SetVideoRotation(kRotation); |
565 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 565 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
566 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); | 566 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); |
567 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); | 567 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); |
568 | 568 |
569 RtpHeaderExtensionMap map; | 569 RtpHeaderExtensionMap map; |
570 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); | 570 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); |
571 | 571 |
572 size_t length = static_cast<size_t>( | 572 size_t length = static_cast<size_t>( |
573 rtp_sender_->BuildRTPheader(packet_, kPayload, false, kTimestamp, 0)); | 573 rtp_sender_->BuildRtpHeader(packet_, kPayload, false, kTimestamp, 0)); |
574 ASSERT_EQ(kRtpHeaderSize, length); | 574 ASSERT_EQ(kRtpHeaderSize, length); |
575 | 575 |
576 // Verify | 576 // Verify |
577 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 577 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
578 webrtc::RTPHeader rtp_header; | 578 webrtc::RTPHeader rtp_header; |
579 | 579 |
580 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map)); | 580 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map)); |
581 ASSERT_FALSE(rtp_parser.RTCP()); | 581 ASSERT_FALSE(rtp_parser.RTCP()); |
582 VerifyRTPHeaderCommon(rtp_header, false); | 582 VerifyRTPHeaderCommon(rtp_header, false); |
583 EXPECT_EQ(length, rtp_header.headerLength); | 583 EXPECT_EQ(length, rtp_header.headerLength); |
584 EXPECT_FALSE(rtp_header.extension.hasVideoRotation); | 584 EXPECT_FALSE(rtp_header.extension.hasVideoRotation); |
585 } | 585 } |
586 | 586 |
587 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) { | 587 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) { |
588 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, | 588 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, |
589 kAudioLevelExtensionId)); | 589 kAudioLevelExtensionId)); |
590 | 590 |
591 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 591 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader( |
592 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 592 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
593 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); | 593 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); |
594 | 594 |
595 // Verify | 595 // Verify |
596 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 596 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
597 webrtc::RTPHeader rtp_header; | 597 webrtc::RTPHeader rtp_header; |
598 | 598 |
599 // Updating audio level is done in RTPSenderAudio, so simulate it here. | 599 // Updating audio level is done in RTPSenderAudio, so simulate it here. |
600 rtp_parser.Parse(&rtp_header); | 600 rtp_parser.Parse(&rtp_header); |
601 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel); | 601 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel); |
(...skipping 22 matching lines...) Expand all Loading... |
624 EXPECT_EQ(0u, rtp_header2.extension.audioLevel); | 624 EXPECT_EQ(0u, rtp_header2.extension.audioLevel); |
625 } | 625 } |
626 | 626 |
627 TEST_F(RtpSenderTestWithoutPacer, | 627 TEST_F(RtpSenderTestWithoutPacer, |
628 BuildRTPPacketWithCSRCAndAudioLevelExtension) { | 628 BuildRTPPacketWithCSRCAndAudioLevelExtension) { |
629 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, | 629 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, |
630 kAudioLevelExtensionId)); | 630 kAudioLevelExtensionId)); |
631 std::vector<uint32_t> csrcs; | 631 std::vector<uint32_t> csrcs; |
632 csrcs.push_back(0x23456789); | 632 csrcs.push_back(0x23456789); |
633 rtp_sender_->SetCsrcs(csrcs); | 633 rtp_sender_->SetCsrcs(csrcs); |
634 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 634 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader( |
635 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 635 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
636 | 636 |
637 // Verify | 637 // Verify |
638 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 638 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
639 webrtc::RTPHeader rtp_header; | 639 webrtc::RTPHeader rtp_header; |
640 | 640 |
641 // Updating audio level is done in RTPSenderAudio, so simulate it here. | 641 // Updating audio level is done in RTPSenderAudio, so simulate it here. |
642 rtp_parser.Parse(&rtp_header); | 642 rtp_parser.Parse(&rtp_header); |
643 EXPECT_TRUE(rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, | 643 EXPECT_TRUE(rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, |
644 kAudioLevel)); | 644 kAudioLevel)); |
(...skipping 23 matching lines...) Expand all Loading... |
668 kTransmissionTimeOffsetExtensionId)); | 668 kTransmissionTimeOffsetExtensionId)); |
669 EXPECT_EQ( | 669 EXPECT_EQ( |
670 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 670 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, |
671 kAbsoluteSendTimeExtensionId)); | 671 kAbsoluteSendTimeExtensionId)); |
672 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, | 672 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, |
673 kAudioLevelExtensionId)); | 673 kAudioLevelExtensionId)); |
674 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 674 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
675 kRtpExtensionTransportSequenceNumber, | 675 kRtpExtensionTransportSequenceNumber, |
676 kTransportSequenceNumberExtensionId)); | 676 kTransportSequenceNumberExtensionId)); |
677 | 677 |
678 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 678 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader( |
679 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 679 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
680 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); | 680 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); |
681 | 681 |
682 // Verify | 682 // Verify |
683 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 683 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
684 webrtc::RTPHeader rtp_header; | 684 webrtc::RTPHeader rtp_header; |
685 | 685 |
686 // Updating audio level is done in RTPSenderAudio, so simulate it here. | 686 // Updating audio level is done in RTPSenderAudio, so simulate it here. |
687 rtp_parser.Parse(&rtp_header); | 687 rtp_parser.Parse(&rtp_header); |
688 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel); | 688 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel); |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
738 | 738 |
739 rtp_sender_->SetStorePacketsStatus(true, 10); | 739 rtp_sender_->SetStorePacketsStatus(true, 10); |
740 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 740 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
741 kRtpExtensionTransmissionTimeOffset, | 741 kRtpExtensionTransmissionTimeOffset, |
742 kTransmissionTimeOffsetExtensionId)); | 742 kTransmissionTimeOffsetExtensionId)); |
743 EXPECT_EQ( | 743 EXPECT_EQ( |
744 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 744 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, |
745 kAbsoluteSendTimeExtensionId)); | 745 kAbsoluteSendTimeExtensionId)); |
746 rtp_sender_->SetTargetBitrate(300000); | 746 rtp_sender_->SetTargetBitrate(300000); |
747 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 747 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
748 int rtp_length_int = rtp_sender_->BuildRTPheader( | 748 int rtp_length_int = rtp_sender_->BuildRtpHeader( |
749 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); | 749 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); |
750 ASSERT_NE(-1, rtp_length_int); | 750 ASSERT_NE(-1, rtp_length_int); |
751 size_t rtp_length = static_cast<size_t>(rtp_length_int); | 751 size_t rtp_length = static_cast<size_t>(rtp_length_int); |
752 | 752 |
753 // Packet should be stored in a send bucket. | 753 // Packet should be stored in a send bucket. |
754 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, | 754 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, |
755 capture_time_ms, kAllowRetransmission, | 755 capture_time_ms, kAllowRetransmission, |
756 RtpPacketSender::kNormalPriority)); | 756 RtpPacketSender::kNormalPriority)); |
757 | 757 |
758 EXPECT_EQ(0, transport_.packets_sent_); | 758 EXPECT_EQ(0, transport_.packets_sent_); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
792 | 792 |
793 rtp_sender_->SetStorePacketsStatus(true, 10); | 793 rtp_sender_->SetStorePacketsStatus(true, 10); |
794 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 794 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
795 kRtpExtensionTransmissionTimeOffset, | 795 kRtpExtensionTransmissionTimeOffset, |
796 kTransmissionTimeOffsetExtensionId)); | 796 kTransmissionTimeOffsetExtensionId)); |
797 EXPECT_EQ( | 797 EXPECT_EQ( |
798 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 798 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, |
799 kAbsoluteSendTimeExtensionId)); | 799 kAbsoluteSendTimeExtensionId)); |
800 rtp_sender_->SetTargetBitrate(300000); | 800 rtp_sender_->SetTargetBitrate(300000); |
801 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 801 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
802 int rtp_length_int = rtp_sender_->BuildRTPheader( | 802 int rtp_length_int = rtp_sender_->BuildRtpHeader( |
803 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); | 803 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); |
804 ASSERT_NE(-1, rtp_length_int); | 804 ASSERT_NE(-1, rtp_length_int); |
805 size_t rtp_length = static_cast<size_t>(rtp_length_int); | 805 size_t rtp_length = static_cast<size_t>(rtp_length_int); |
806 | 806 |
807 // Packet should be stored in a send bucket. | 807 // Packet should be stored in a send bucket. |
808 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, | 808 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, |
809 capture_time_ms, kAllowRetransmission, | 809 capture_time_ms, kAllowRetransmission, |
810 RtpPacketSender::kNormalPriority)); | 810 RtpPacketSender::kNormalPriority)); |
811 | 811 |
812 EXPECT_EQ(0, transport_.packets_sent_); | 812 EXPECT_EQ(0, transport_.packets_sent_); |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
874 webrtc::RtpHeaderParser::Create()); | 874 webrtc::RtpHeaderParser::Create()); |
875 ASSERT_TRUE(rtp_parser.get() != nullptr); | 875 ASSERT_TRUE(rtp_parser.get() != nullptr); |
876 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset, | 876 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset, |
877 kTransmissionTimeOffsetExtensionId); | 877 kTransmissionTimeOffsetExtensionId); |
878 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 878 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, |
879 kAbsoluteSendTimeExtensionId); | 879 kAbsoluteSendTimeExtensionId); |
880 webrtc::RTPHeader rtp_header; | 880 webrtc::RTPHeader rtp_header; |
881 | 881 |
882 rtp_sender_->SetTargetBitrate(300000); | 882 rtp_sender_->SetTargetBitrate(300000); |
883 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 883 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
884 int rtp_length_int = rtp_sender_->BuildRTPheader( | 884 int rtp_length_int = rtp_sender_->BuildRtpHeader( |
885 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms); | 885 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms); |
886 const uint32_t media_packet_timestamp = timestamp; | 886 const uint32_t media_packet_timestamp = timestamp; |
887 ASSERT_NE(-1, rtp_length_int); | 887 ASSERT_NE(-1, rtp_length_int); |
888 size_t rtp_length = static_cast<size_t>(rtp_length_int); | 888 size_t rtp_length = static_cast<size_t>(rtp_length_int); |
889 | 889 |
890 // Packet should be stored in a send bucket. | 890 // Packet should be stored in a send bucket. |
891 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, | 891 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, |
892 capture_time_ms, kAllowRetransmission, | 892 capture_time_ms, kAllowRetransmission, |
893 RtpPacketSender::kNormalPriority)); | 893 RtpPacketSender::kNormalPriority)); |
894 | 894 |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
932 EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset); | 932 EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset); |
933 uint64_t expected_send_time = | 933 uint64_t expected_send_time = |
934 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); | 934 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); |
935 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); | 935 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); |
936 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs); | 936 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs); |
937 timestamp += 90 * kPaddingPeriodMs; | 937 timestamp += 90 * kPaddingPeriodMs; |
938 } | 938 } |
939 | 939 |
940 // Send a regular video packet again. | 940 // Send a regular video packet again. |
941 capture_time_ms = fake_clock_.TimeInMilliseconds(); | 941 capture_time_ms = fake_clock_.TimeInMilliseconds(); |
942 rtp_length_int = rtp_sender_->BuildRTPheader(packet_, kPayload, kMarkerBit, | 942 rtp_length_int = rtp_sender_->BuildRtpHeader(packet_, kPayload, kMarkerBit, |
943 timestamp, capture_time_ms); | 943 timestamp, capture_time_ms); |
944 ASSERT_NE(-1, rtp_length_int); | 944 ASSERT_NE(-1, rtp_length_int); |
945 rtp_length = static_cast<size_t>(rtp_length_int); | 945 rtp_length = static_cast<size_t>(rtp_length_int); |
946 | 946 |
947 EXPECT_CALL(mock_paced_sender_, | 947 EXPECT_CALL(mock_paced_sender_, |
948 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)); | 948 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)); |
949 | 949 |
950 // Packet should be stored in a send bucket. | 950 // Packet should be stored in a send bucket. |
951 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, | 951 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, |
952 capture_time_ms, kAllowRetransmission, | 952 capture_time_ms, kAllowRetransmission, |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1103 } | 1103 } |
1104 | 1104 |
1105 TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) { | 1105 TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) { |
1106 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; | 1106 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; |
1107 const uint8_t payload_type = 127; | 1107 const uint8_t payload_type = 127; |
1108 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, | 1108 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, |
1109 0, 1500)); | 1109 0, 1500)); |
1110 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1110 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1111 | 1111 |
1112 // Send keyframe | 1112 // Send keyframe |
1113 ASSERT_EQ( | 1113 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, |
1114 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321, | 1114 4321, payload, sizeof(payload), |
1115 payload, sizeof(payload), nullptr)); | 1115 nullptr, nullptr)); |
1116 | 1116 |
1117 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, | 1117 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, |
1118 transport_.last_sent_packet_len_); | 1118 transport_.last_sent_packet_len_); |
1119 webrtc::RTPHeader rtp_header; | 1119 webrtc::RTPHeader rtp_header; |
1120 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); | 1120 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); |
1121 | 1121 |
1122 const uint8_t* payload_data = | 1122 const uint8_t* payload_data = |
1123 GetPayloadData(rtp_header, transport_.last_sent_packet_); | 1123 GetPayloadData(rtp_header, transport_.last_sent_packet_); |
1124 uint8_t generic_header = *payload_data++; | 1124 uint8_t generic_header = *payload_data++; |
1125 | 1125 |
1126 ASSERT_EQ(sizeof(payload) + sizeof(generic_header), | 1126 ASSERT_EQ(sizeof(payload) + sizeof(generic_header), |
1127 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_)); | 1127 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_)); |
1128 | 1128 |
1129 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); | 1129 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); |
1130 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); | 1130 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); |
1131 | 1131 |
1132 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload))); | 1132 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload))); |
1133 | 1133 |
1134 // Send delta frame | 1134 // Send delta frame |
1135 payload[0] = 13; | 1135 payload[0] = 13; |
1136 payload[1] = 42; | 1136 payload[1] = 42; |
1137 payload[4] = 13; | 1137 payload[4] = 13; |
1138 | 1138 |
1139 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type, | 1139 ASSERT_EQ(0, rtp_sender_->SendOutgoingData( |
1140 1234, 4321, payload, | 1140 kVideoFrameDelta, payload_type, 1234, 4321, payload, |
1141 sizeof(payload), nullptr)); | 1141 sizeof(payload), nullptr, nullptr)); |
1142 | 1142 |
1143 RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_, | 1143 RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_, |
1144 transport_.last_sent_packet_len_); | 1144 transport_.last_sent_packet_len_); |
1145 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); | 1145 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); |
1146 | 1146 |
1147 payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_); | 1147 payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_); |
1148 generic_header = *payload_data++; | 1148 generic_header = *payload_data++; |
1149 | 1149 |
1150 EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); | 1150 EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); |
1151 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); | 1151 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); |
(...skipping 30 matching lines...) Expand all Loading... |
1182 const uint8_t payload_type = 127; | 1182 const uint8_t payload_type = 127; |
1183 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, | 1183 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, |
1184 0, 1500)); | 1184 0, 1500)); |
1185 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1185 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1186 rtp_sender_->SetStorePacketsStatus(true, 1); | 1186 rtp_sender_->SetStorePacketsStatus(true, 1); |
1187 uint32_t ssrc = rtp_sender_->SSRC(); | 1187 uint32_t ssrc = rtp_sender_->SSRC(); |
1188 | 1188 |
1189 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)) | 1189 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)) |
1190 .Times(::testing::AtLeast(2)); | 1190 .Times(::testing::AtLeast(2)); |
1191 | 1191 |
1192 ASSERT_EQ( | 1192 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, |
1193 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321, | 1193 4321, payload, sizeof(payload), |
1194 payload, sizeof(payload), nullptr)); | 1194 nullptr, nullptr)); |
1195 | 1195 |
1196 EXPECT_EQ(1U, callback.num_calls_); | 1196 EXPECT_EQ(1U, callback.num_calls_); |
1197 EXPECT_EQ(ssrc, callback.ssrc_); | 1197 EXPECT_EQ(ssrc, callback.ssrc_); |
1198 EXPECT_EQ(1, callback.frame_counts_.key_frames); | 1198 EXPECT_EQ(1, callback.frame_counts_.key_frames); |
1199 EXPECT_EQ(0, callback.frame_counts_.delta_frames); | 1199 EXPECT_EQ(0, callback.frame_counts_.delta_frames); |
1200 | 1200 |
1201 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type, | 1201 ASSERT_EQ(0, rtp_sender_->SendOutgoingData( |
1202 1234, 4321, payload, | 1202 kVideoFrameDelta, payload_type, 1234, 4321, payload, |
1203 sizeof(payload), nullptr)); | 1203 sizeof(payload), nullptr, nullptr)); |
1204 | 1204 |
1205 EXPECT_EQ(2U, callback.num_calls_); | 1205 EXPECT_EQ(2U, callback.num_calls_); |
1206 EXPECT_EQ(ssrc, callback.ssrc_); | 1206 EXPECT_EQ(ssrc, callback.ssrc_); |
1207 EXPECT_EQ(1, callback.frame_counts_.key_frames); | 1207 EXPECT_EQ(1, callback.frame_counts_.key_frames); |
1208 EXPECT_EQ(1, callback.frame_counts_.delta_frames); | 1208 EXPECT_EQ(1, callback.frame_counts_.delta_frames); |
1209 | 1209 |
1210 rtp_sender_.reset(); | 1210 rtp_sender_.reset(); |
1211 } | 1211 } |
1212 | 1212 |
1213 TEST_F(RtpSenderTest, BitrateCallbacks) { | 1213 TEST_F(RtpSenderTest, BitrateCallbacks) { |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1247 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1247 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1248 rtp_sender_->SetStorePacketsStatus(true, 1); | 1248 rtp_sender_->SetStorePacketsStatus(true, 1); |
1249 uint32_t ssrc = rtp_sender_->SSRC(); | 1249 uint32_t ssrc = rtp_sender_->SSRC(); |
1250 | 1250 |
1251 // Initial process call so we get a new time window. | 1251 // Initial process call so we get a new time window. |
1252 rtp_sender_->ProcessBitrate(); | 1252 rtp_sender_->ProcessBitrate(); |
1253 uint64_t start_time = fake_clock_.CurrentNtpInMilliseconds(); | 1253 uint64_t start_time = fake_clock_.CurrentNtpInMilliseconds(); |
1254 | 1254 |
1255 // Send a few frames. | 1255 // Send a few frames. |
1256 for (uint32_t i = 0; i < kNumPackets; ++i) { | 1256 for (uint32_t i = 0; i < kNumPackets; ++i) { |
1257 ASSERT_EQ(0, | 1257 ASSERT_EQ(0, rtp_sender_->SendOutgoingData( |
1258 rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, | 1258 kVideoFrameKey, payload_type, 1234, 4321, payload, |
1259 4321, payload, sizeof(payload), 0)); | 1259 sizeof(payload), nullptr, nullptr)); |
1260 fake_clock_.AdvanceTimeMilliseconds(kPacketInterval); | 1260 fake_clock_.AdvanceTimeMilliseconds(kPacketInterval); |
1261 } | 1261 } |
1262 | 1262 |
1263 rtp_sender_->ProcessBitrate(); | 1263 rtp_sender_->ProcessBitrate(); |
1264 | 1264 |
1265 const uint32_t expected_packet_rate = 1000 / kPacketInterval; | 1265 const uint32_t expected_packet_rate = 1000 / kPacketInterval; |
1266 | 1266 |
1267 // We get one call for every stats updated, thus two calls since both the | 1267 // We get one call for every stats updated, thus two calls since both the |
1268 // stream stats and the retransmit stats are updated once. | 1268 // stream stats and the retransmit stats are updated once. |
1269 EXPECT_EQ(2u, callback.num_calls_); | 1269 EXPECT_EQ(2u, callback.num_calls_); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1327 const uint8_t payload_type = 127; | 1327 const uint8_t payload_type = 127; |
1328 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, | 1328 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, |
1329 0, 1500)); | 1329 0, 1500)); |
1330 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1330 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1331 rtp_sender_->SetStorePacketsStatus(true, 1); | 1331 rtp_sender_->SetStorePacketsStatus(true, 1); |
1332 uint32_t ssrc = rtp_sender_->SSRC(); | 1332 uint32_t ssrc = rtp_sender_->SSRC(); |
1333 | 1333 |
1334 rtp_sender_->RegisterRtpStatisticsCallback(&callback); | 1334 rtp_sender_->RegisterRtpStatisticsCallback(&callback); |
1335 | 1335 |
1336 // Send a frame. | 1336 // Send a frame. |
1337 ASSERT_EQ( | 1337 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, |
1338 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321, | 1338 4321, payload, sizeof(payload), |
1339 payload, sizeof(payload), nullptr)); | 1339 nullptr, nullptr)); |
1340 StreamDataCounters expected; | 1340 StreamDataCounters expected; |
1341 expected.transmitted.payload_bytes = 6; | 1341 expected.transmitted.payload_bytes = 6; |
1342 expected.transmitted.header_bytes = 12; | 1342 expected.transmitted.header_bytes = 12; |
1343 expected.transmitted.padding_bytes = 0; | 1343 expected.transmitted.padding_bytes = 0; |
1344 expected.transmitted.packets = 1; | 1344 expected.transmitted.packets = 1; |
1345 expected.retransmitted.payload_bytes = 0; | 1345 expected.retransmitted.payload_bytes = 0; |
1346 expected.retransmitted.header_bytes = 0; | 1346 expected.retransmitted.header_bytes = 0; |
1347 expected.retransmitted.padding_bytes = 0; | 1347 expected.retransmitted.padding_bytes = 0; |
1348 expected.retransmitted.packets = 0; | 1348 expected.retransmitted.packets = 0; |
1349 expected.fec.packets = 0; | 1349 expected.fec.packets = 0; |
(...skipping 19 matching lines...) Expand all Loading... |
1369 expected.transmitted.packets = 3; | 1369 expected.transmitted.packets = 3; |
1370 callback.Matches(ssrc, expected); | 1370 callback.Matches(ssrc, expected); |
1371 | 1371 |
1372 // Send FEC. | 1372 // Send FEC. |
1373 rtp_sender_->SetGenericFECStatus(true, kRedPayloadType, kUlpfecPayloadType); | 1373 rtp_sender_->SetGenericFECStatus(true, kRedPayloadType, kUlpfecPayloadType); |
1374 FecProtectionParams fec_params; | 1374 FecProtectionParams fec_params; |
1375 fec_params.fec_mask_type = kFecMaskRandom; | 1375 fec_params.fec_mask_type = kFecMaskRandom; |
1376 fec_params.fec_rate = 1; | 1376 fec_params.fec_rate = 1; |
1377 fec_params.max_fec_frames = 1; | 1377 fec_params.max_fec_frames = 1; |
1378 rtp_sender_->SetFecParameters(&fec_params, &fec_params); | 1378 rtp_sender_->SetFecParameters(&fec_params, &fec_params); |
1379 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type, | 1379 ASSERT_EQ(0, rtp_sender_->SendOutgoingData( |
1380 1234, 4321, payload, | 1380 kVideoFrameDelta, payload_type, 1234, 4321, payload, |
1381 sizeof(payload), nullptr)); | 1381 sizeof(payload), nullptr, nullptr)); |
1382 expected.transmitted.payload_bytes = 40; | 1382 expected.transmitted.payload_bytes = 40; |
1383 expected.transmitted.header_bytes = 60; | 1383 expected.transmitted.header_bytes = 60; |
1384 expected.transmitted.packets = 5; | 1384 expected.transmitted.packets = 5; |
1385 expected.fec.packets = 1; | 1385 expected.fec.packets = 1; |
1386 callback.Matches(ssrc, expected); | 1386 callback.Matches(ssrc, expected); |
1387 | 1387 |
1388 rtp_sender_->RegisterRtpStatisticsCallback(nullptr); | 1388 rtp_sender_->RegisterRtpStatisticsCallback(nullptr); |
1389 } | 1389 } |
1390 | 1390 |
1391 TEST_F(RtpSenderAudioTest, SendAudio) { | 1391 TEST_F(RtpSenderAudioTest, SendAudio) { |
1392 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; | 1392 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; |
1393 const uint8_t payload_type = 127; | 1393 const uint8_t payload_type = 127; |
1394 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, | 1394 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, |
1395 0, 1500)); | 1395 0, 1500)); |
1396 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1396 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1397 | 1397 |
1398 ASSERT_EQ( | 1398 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234, |
1399 0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234, 4321, | 1399 4321, payload, sizeof(payload), |
1400 payload, sizeof(payload), nullptr)); | 1400 nullptr, nullptr)); |
1401 | 1401 |
1402 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, | 1402 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, |
1403 transport_.last_sent_packet_len_); | 1403 transport_.last_sent_packet_len_); |
1404 webrtc::RTPHeader rtp_header; | 1404 webrtc::RTPHeader rtp_header; |
1405 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); | 1405 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); |
1406 | 1406 |
1407 const uint8_t* payload_data = | 1407 const uint8_t* payload_data = |
1408 GetPayloadData(rtp_header, transport_.last_sent_packet_); | 1408 GetPayloadData(rtp_header, transport_.last_sent_packet_); |
1409 | 1409 |
1410 ASSERT_EQ(sizeof(payload), | 1410 ASSERT_EQ(sizeof(payload), |
1411 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_)); | 1411 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_)); |
1412 | 1412 |
1413 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload))); | 1413 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload))); |
1414 } | 1414 } |
1415 | 1415 |
1416 TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) { | 1416 TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) { |
1417 EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel)); | 1417 EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel)); |
1418 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, | 1418 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, |
1419 kAudioLevelExtensionId)); | 1419 kAudioLevelExtensionId)); |
1420 | 1420 |
1421 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; | 1421 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; |
1422 const uint8_t payload_type = 127; | 1422 const uint8_t payload_type = 127; |
1423 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, | 1423 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, |
1424 0, 1500)); | 1424 0, 1500)); |
1425 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1425 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1426 | 1426 |
1427 ASSERT_EQ( | 1427 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234, |
1428 0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234, 4321, | 1428 4321, payload, sizeof(payload), |
1429 payload, sizeof(payload), nullptr)); | 1429 nullptr, nullptr)); |
1430 | 1430 |
1431 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, | 1431 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, |
1432 transport_.last_sent_packet_len_); | 1432 transport_.last_sent_packet_len_); |
1433 webrtc::RTPHeader rtp_header; | 1433 webrtc::RTPHeader rtp_header; |
1434 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); | 1434 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); |
1435 | 1435 |
1436 const uint8_t* payload_data = | 1436 const uint8_t* payload_data = |
1437 GetPayloadData(rtp_header, transport_.last_sent_packet_); | 1437 GetPayloadData(rtp_header, transport_.last_sent_packet_); |
1438 | 1438 |
1439 ASSERT_EQ(sizeof(payload), | 1439 ASSERT_EQ(sizeof(payload), |
(...skipping 30 matching lines...) Expand all Loading... |
1470 ASSERT_EQ( | 1470 ASSERT_EQ( |
1471 0, rtp_sender_->RegisterPayload(kPayloadName, payload_type, 8000, 1, 0)); | 1471 0, rtp_sender_->RegisterPayload(kPayloadName, payload_type, 8000, 1, 0)); |
1472 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 1472 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
1473 // DTMF event key=9, duration=500 and attenuationdB=10 | 1473 // DTMF event key=9, duration=500 and attenuationdB=10 |
1474 rtp_sender_->SendTelephoneEvent(9, 500, 10); | 1474 rtp_sender_->SendTelephoneEvent(9, 500, 10); |
1475 // During start, it takes the starting timestamp as last sent timestamp. | 1475 // During start, it takes the starting timestamp as last sent timestamp. |
1476 // The duration is calculated as the difference of current and last sent | 1476 // The duration is calculated as the difference of current and last sent |
1477 // timestamp. So for first call it will skip since the duration is zero. | 1477 // timestamp. So for first call it will skip since the duration is zero. |
1478 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, | 1478 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, |
1479 capture_time_ms, 0, nullptr, 0, | 1479 capture_time_ms, 0, nullptr, 0, |
1480 nullptr)); | 1480 nullptr, nullptr)); |
1481 // DTMF Sample Length is (Frequency/1000) * Duration. | 1481 // DTMF Sample Length is (Frequency/1000) * Duration. |
1482 // So in this case, it is (8000/1000) * 500 = 4000. | 1482 // So in this case, it is (8000/1000) * 500 = 4000. |
1483 // Sending it as two packets. | 1483 // Sending it as two packets. |
1484 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, | 1484 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, |
1485 capture_time_ms + 2000, 0, nullptr, | 1485 capture_time_ms + 2000, 0, nullptr, |
1486 0, nullptr)); | 1486 0, nullptr, nullptr)); |
1487 std::unique_ptr<webrtc::RtpHeaderParser> rtp_parser( | 1487 std::unique_ptr<webrtc::RtpHeaderParser> rtp_parser( |
1488 webrtc::RtpHeaderParser::Create()); | 1488 webrtc::RtpHeaderParser::Create()); |
1489 ASSERT_TRUE(rtp_parser.get() != nullptr); | 1489 ASSERT_TRUE(rtp_parser.get() != nullptr); |
1490 webrtc::RTPHeader rtp_header; | 1490 webrtc::RTPHeader rtp_header; |
1491 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, | 1491 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, |
1492 transport_.last_sent_packet_len_, &rtp_header)); | 1492 transport_.last_sent_packet_len_, &rtp_header)); |
1493 // Marker Bit should be set to 1 for first packet. | 1493 // Marker Bit should be set to 1 for first packet. |
1494 EXPECT_TRUE(rtp_header.markerBit); | 1494 EXPECT_TRUE(rtp_header.markerBit); |
1495 | 1495 |
1496 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, | 1496 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, |
1497 capture_time_ms + 4000, 0, nullptr, | 1497 capture_time_ms + 4000, 0, nullptr, |
1498 0, nullptr)); | 1498 0, nullptr, nullptr)); |
1499 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, | 1499 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, |
1500 transport_.last_sent_packet_len_, &rtp_header)); | 1500 transport_.last_sent_packet_len_, &rtp_header)); |
1501 // Marker Bit should be set to 0 for rest of the packets. | 1501 // Marker Bit should be set to 0 for rest of the packets. |
1502 EXPECT_FALSE(rtp_header.markerBit); | 1502 EXPECT_FALSE(rtp_header.markerBit); |
1503 } | 1503 } |
1504 | 1504 |
1505 TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { | 1505 TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { |
1506 const char* kPayloadName = "GENERIC"; | 1506 const char* kPayloadName = "GENERIC"; |
1507 const uint8_t kPayloadType = 127; | 1507 const uint8_t kPayloadType = 127; |
1508 rtp_sender_->SetSSRC(1234); | 1508 rtp_sender_->SetSSRC(1234); |
1509 rtp_sender_->SetRtxSsrc(4321); | 1509 rtp_sender_->SetRtxSsrc(4321); |
1510 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType); | 1510 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType); |
1511 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); | 1511 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); |
1512 | 1512 |
1513 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000, | 1513 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000, |
1514 0, 1500)); | 1514 0, 1500)); |
1515 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1515 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1516 | 1516 |
1517 ASSERT_EQ( | 1517 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, kPayloadType, 1234, |
1518 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, kPayloadType, 1234, 4321, | 1518 4321, payload, sizeof(payload), |
1519 payload, sizeof(payload), 0)); | 1519 nullptr, nullptr)); |
1520 | 1520 |
1521 // Will send 2 full-size padding packets. | 1521 // Will send 2 full-size padding packets. |
1522 rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe); | 1522 rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe); |
1523 rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe); | 1523 rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe); |
1524 | 1524 |
1525 StreamDataCounters rtp_stats; | 1525 StreamDataCounters rtp_stats; |
1526 StreamDataCounters rtx_stats; | 1526 StreamDataCounters rtx_stats; |
1527 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats); | 1527 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats); |
1528 | 1528 |
1529 // Payload + 1-byte generic header. | 1529 // Payload + 1-byte generic header. |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1603 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()), | 1603 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()), |
1604 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation); | 1604 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation); |
1605 | 1605 |
1606 // Verify that this packet does have CVO byte. | 1606 // Verify that this packet does have CVO byte. |
1607 VerifyCVOPacket( | 1607 VerifyCVOPacket( |
1608 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()), | 1608 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()), |
1609 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1, | 1609 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1, |
1610 hdr.rotation); | 1610 hdr.rotation); |
1611 } | 1611 } |
1612 } // namespace webrtc | 1612 } // namespace webrtc |
OLD | NEW |