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 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
96 BitrateObserver retransmit_bitrate_observer_; | 96 BitrateObserver retransmit_bitrate_observer_; |
97 uint32_t ssrc_; | 97 uint32_t ssrc_; |
98 }; | 98 }; |
99 | 99 |
100 RTPSender::RTPSender(int32_t id, | 100 RTPSender::RTPSender(int32_t id, |
101 bool audio, | 101 bool audio, |
102 Clock* clock, | 102 Clock* clock, |
103 Transport* transport, | 103 Transport* transport, |
104 RtpAudioFeedback* audio_feedback, | 104 RtpAudioFeedback* audio_feedback, |
105 PacedSender* paced_sender, | 105 PacedSender* paced_sender, |
| 106 PacketRouter* packet_router, |
| 107 SendTimeObserver* send_time_observer, |
106 BitrateStatisticsObserver* bitrate_callback, | 108 BitrateStatisticsObserver* bitrate_callback, |
107 FrameCountObserver* frame_count_observer, | 109 FrameCountObserver* frame_count_observer, |
108 SendSideDelayObserver* send_side_delay_observer) | 110 SendSideDelayObserver* send_side_delay_observer) |
109 : clock_(clock), | 111 : clock_(clock), |
110 // TODO(holmer): Remove this conversion when we remove the use of | 112 // TODO(holmer): Remove this conversion when we remove the use of |
111 // TickTime. | 113 // TickTime. |
112 clock_delta_ms_(clock_->TimeInMilliseconds() - | 114 clock_delta_ms_(clock_->TimeInMilliseconds() - |
113 TickTime::MillisecondTimestamp()), | 115 TickTime::MillisecondTimestamp()), |
114 bitrates_(new BitrateAggregator(bitrate_callback)), | 116 bitrates_(new BitrateAggregator(bitrate_callback)), |
115 total_bitrate_sent_(clock, bitrates_->total_bitrate_observer()), | 117 total_bitrate_sent_(clock, bitrates_->total_bitrate_observer()), |
116 id_(id), | 118 id_(id), |
117 audio_configured_(audio), | 119 audio_configured_(audio), |
118 audio_(audio ? new RTPSenderAudio(id, clock, this, audio_feedback) | 120 audio_(audio ? new RTPSenderAudio(id, clock, this, audio_feedback) |
119 : nullptr), | 121 : nullptr), |
120 video_(audio ? nullptr : new RTPSenderVideo(clock, this)), | 122 video_(audio ? nullptr : new RTPSenderVideo(clock, this)), |
121 paced_sender_(paced_sender), | 123 paced_sender_(paced_sender), |
| 124 packet_router_(packet_router), |
| 125 send_time_observer_(send_time_observer), |
122 last_capture_time_ms_sent_(0), | 126 last_capture_time_ms_sent_(0), |
123 send_critsect_(CriticalSectionWrapper::CreateCriticalSection()), | 127 send_critsect_(CriticalSectionWrapper::CreateCriticalSection()), |
124 transport_(transport), | 128 transport_(transport), |
125 sending_media_(true), // Default to sending media. | 129 sending_media_(true), // Default to sending media. |
126 max_payload_length_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP. | 130 max_payload_length_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP. |
127 packet_over_head_(28), | 131 packet_over_head_(28), |
128 payload_type_(-1), | 132 payload_type_(-1), |
129 payload_type_map_(), | 133 payload_type_map_(), |
130 rtp_header_extension_map_(), | 134 rtp_header_extension_map_(), |
131 transmission_time_offset_(0), | 135 transmission_time_offset_(0), |
(...skipping 464 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
596 } | 600 } |
597 } | 601 } |
598 return SendPadData(timestamp, capture_time_ms, bytes); | 602 return SendPadData(timestamp, capture_time_ms, bytes); |
599 } | 603 } |
600 | 604 |
601 size_t RTPSender::SendPadData(uint32_t timestamp, | 605 size_t RTPSender::SendPadData(uint32_t timestamp, |
602 int64_t capture_time_ms, | 606 int64_t capture_time_ms, |
603 size_t bytes) { | 607 size_t bytes) { |
604 size_t padding_bytes_in_packet = 0; | 608 size_t padding_bytes_in_packet = 0; |
605 size_t bytes_sent = 0; | 609 size_t bytes_sent = 0; |
| 610 bool using_transport_seq = rtp_header_extension_map_.IsRegistered( |
| 611 kRtpExtensionTransportSequenceNumber) && |
| 612 packet_router_; |
606 for (; bytes > 0; bytes -= padding_bytes_in_packet) { | 613 for (; bytes > 0; bytes -= padding_bytes_in_packet) { |
607 // Always send full padding packets. | 614 // Always send full padding packets. |
608 if (bytes < kMaxPaddingLength) | 615 if (bytes < kMaxPaddingLength) |
609 bytes = kMaxPaddingLength; | 616 bytes = kMaxPaddingLength; |
610 | 617 |
611 uint32_t ssrc; | 618 uint32_t ssrc; |
612 uint16_t sequence_number; | 619 uint16_t sequence_number; |
613 int payload_type; | 620 int payload_type; |
614 bool over_rtx; | 621 bool over_rtx; |
615 { | 622 { |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
652 RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length); | 659 RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length); |
653 RTPHeader rtp_header; | 660 RTPHeader rtp_header; |
654 rtp_parser.Parse(rtp_header); | 661 rtp_parser.Parse(rtp_header); |
655 | 662 |
656 if (capture_time_ms > 0) { | 663 if (capture_time_ms > 0) { |
657 UpdateTransmissionTimeOffset( | 664 UpdateTransmissionTimeOffset( |
658 padding_packet, length, rtp_header, now_ms - capture_time_ms); | 665 padding_packet, length, rtp_header, now_ms - capture_time_ms); |
659 } | 666 } |
660 | 667 |
661 UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms); | 668 UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms); |
| 669 |
| 670 uint16_t transport_seq = 0; |
| 671 if (using_transport_seq) { |
| 672 transport_seq = |
| 673 UpdateTransportSequenceNumber(padding_packet, length, rtp_header); |
| 674 } |
| 675 |
662 if (!SendPacketToNetwork(padding_packet, length)) | 676 if (!SendPacketToNetwork(padding_packet, length)) |
663 break; | 677 break; |
| 678 |
| 679 if (using_transport_seq) |
| 680 send_time_observer_->OnPacketSent(transport_seq, now_ms); |
| 681 |
664 bytes_sent += padding_bytes_in_packet; | 682 bytes_sent += padding_bytes_in_packet; |
665 UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false); | 683 UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false); |
666 } | 684 } |
667 | 685 |
668 return bytes_sent; | 686 return bytes_sent; |
669 } | 687 } |
670 | 688 |
671 void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) { | 689 void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) { |
672 packet_history_.SetStorePacketsStatus(enable, number_to_store); | 690 packet_history_.SetStorePacketsStatus(enable, number_to_store); |
673 } | 691 } |
(...skipping 29 matching lines...) Expand all Loading... |
703 // We can't send the packet right now. | 721 // We can't send the packet right now. |
704 // We will be called when it is time. | 722 // We will be called when it is time. |
705 return length; | 723 return length; |
706 } | 724 } |
707 } | 725 } |
708 int rtx = kRtxOff; | 726 int rtx = kRtxOff; |
709 { | 727 { |
710 CriticalSectionScoped lock(send_critsect_.get()); | 728 CriticalSectionScoped lock(send_critsect_.get()); |
711 rtx = rtx_; | 729 rtx = rtx_; |
712 } | 730 } |
713 return PrepareAndSendPacket(data_buffer, length, capture_time_ms, | 731 if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms, |
714 (rtx & kRtxRetransmitted) > 0, true) ? | 732 (rtx & kRtxRetransmitted) > 0, true)) { |
715 static_cast<int32_t>(length) : -1; | 733 return -1; |
| 734 } |
| 735 return static_cast<int32_t>(length); |
716 } | 736 } |
717 | 737 |
718 bool RTPSender::SendPacketToNetwork(const uint8_t *packet, size_t size) { | 738 bool RTPSender::SendPacketToNetwork(const uint8_t *packet, size_t size) { |
719 int bytes_sent = -1; | 739 int bytes_sent = -1; |
720 if (transport_) { | 740 if (transport_) { |
721 bytes_sent = transport_->SendPacket(id_, packet, size); | 741 bytes_sent = transport_->SendPacket(id_, packet, size); |
722 } | 742 } |
723 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), | 743 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
724 "RTPSender::SendPacketToNetwork", "size", size, "sent", | 744 "RTPSender::SendPacketToNetwork", "size", size, "sent", |
725 bytes_sent); | 745 bytes_sent); |
(...skipping 164 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
890 if (send_over_rtx) { | 910 if (send_over_rtx) { |
891 BuildRtxPacket(buffer, &length, data_buffer_rtx); | 911 BuildRtxPacket(buffer, &length, data_buffer_rtx); |
892 buffer_to_send_ptr = data_buffer_rtx; | 912 buffer_to_send_ptr = data_buffer_rtx; |
893 } | 913 } |
894 | 914 |
895 int64_t now_ms = clock_->TimeInMilliseconds(); | 915 int64_t now_ms = clock_->TimeInMilliseconds(); |
896 int64_t diff_ms = now_ms - capture_time_ms; | 916 int64_t diff_ms = now_ms - capture_time_ms; |
897 UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header, | 917 UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header, |
898 diff_ms); | 918 diff_ms); |
899 UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms); | 919 UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms); |
| 920 |
| 921 uint16_t transport_seq = 0; |
| 922 bool using_transport_seq = rtp_header_extension_map_.IsRegistered( |
| 923 kRtpExtensionTransportSequenceNumber) && |
| 924 packet_router_; |
| 925 if (using_transport_seq) { |
| 926 transport_seq = |
| 927 UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header); |
| 928 } |
| 929 |
900 bool ret = SendPacketToNetwork(buffer_to_send_ptr, length); | 930 bool ret = SendPacketToNetwork(buffer_to_send_ptr, length); |
901 if (ret) { | 931 if (ret) { |
902 CriticalSectionScoped lock(send_critsect_.get()); | 932 CriticalSectionScoped lock(send_critsect_.get()); |
903 media_has_been_sent_ = true; | 933 media_has_been_sent_ = true; |
904 } | 934 } |
| 935 if (using_transport_seq) |
| 936 send_time_observer_->OnPacketSent(transport_seq, now_ms); |
905 UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx, | 937 UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx, |
906 is_retransmit); | 938 is_retransmit); |
907 return ret; | 939 return ret; |
908 } | 940 } |
909 | 941 |
910 void RTPSender::UpdateRtpStats(const uint8_t* buffer, | 942 void RTPSender::UpdateRtpStats(const uint8_t* buffer, |
911 size_t packet_length, | 943 size_t packet_length, |
912 const RTPHeader& header, | 944 const RTPHeader& header, |
913 bool is_rtx, | 945 bool is_rtx, |
914 bool is_retransmit) { | 946 bool is_retransmit) { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
953 return fec_enabled && | 985 return fec_enabled && |
954 header.payloadType == pt_red && | 986 header.payloadType == pt_red && |
955 buffer[header.headerLength] == pt_fec; | 987 buffer[header.headerLength] == pt_fec; |
956 } | 988 } |
957 | 989 |
958 size_t RTPSender::TimeToSendPadding(size_t bytes) { | 990 size_t RTPSender::TimeToSendPadding(size_t bytes) { |
959 if (bytes == 0) | 991 if (bytes == 0) |
960 return 0; | 992 return 0; |
961 { | 993 { |
962 CriticalSectionScoped cs(send_critsect_.get()); | 994 CriticalSectionScoped cs(send_critsect_.get()); |
963 if (!sending_media_) return 0; | 995 if (!sending_media_) |
| 996 return 0; |
964 } | 997 } |
965 size_t bytes_sent = TrySendRedundantPayloads(bytes); | 998 size_t bytes_sent = TrySendRedundantPayloads(bytes); |
966 if (bytes_sent < bytes) | 999 if (bytes_sent < bytes) |
967 bytes_sent += TrySendPadData(bytes - bytes_sent); | 1000 bytes_sent += TrySendPadData(bytes - bytes_sent); |
968 return bytes_sent; | 1001 return bytes_sent; |
969 } | 1002 } |
970 | 1003 |
971 // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again. | 1004 // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again. |
972 int32_t RTPSender::SendToNetwork( | 1005 int32_t RTPSender::SendToNetwork( |
973 uint8_t *buffer, size_t payload_length, size_t rtp_header_length, | 1006 uint8_t *buffer, size_t payload_length, size_t rtp_header_length, |
(...skipping 231 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1205 case kRtpExtensionAudioLevel: | 1238 case kRtpExtensionAudioLevel: |
1206 block_length = BuildAudioLevelExtension(extension_data); | 1239 block_length = BuildAudioLevelExtension(extension_data); |
1207 break; | 1240 break; |
1208 case kRtpExtensionAbsoluteSendTime: | 1241 case kRtpExtensionAbsoluteSendTime: |
1209 block_length = BuildAbsoluteSendTimeExtension(extension_data); | 1242 block_length = BuildAbsoluteSendTimeExtension(extension_data); |
1210 break; | 1243 break; |
1211 case kRtpExtensionVideoRotation: | 1244 case kRtpExtensionVideoRotation: |
1212 block_length = BuildVideoRotationExtension(extension_data); | 1245 block_length = BuildVideoRotationExtension(extension_data); |
1213 break; | 1246 break; |
1214 case kRtpExtensionTransportSequenceNumber: | 1247 case kRtpExtensionTransportSequenceNumber: |
1215 block_length = BuildTransportSequenceNumberExtension(extension_data); | 1248 block_length = BuildTransportSequenceNumberExtension( |
| 1249 extension_data, transport_sequence_number_); |
1216 break; | 1250 break; |
1217 default: | 1251 default: |
1218 assert(false); | 1252 assert(false); |
1219 } | 1253 } |
1220 total_block_length += block_length; | 1254 total_block_length += block_length; |
1221 type = rtp_header_extension_map_.Next(type); | 1255 type = rtp_header_extension_map_.Next(type); |
1222 } | 1256 } |
1223 if (total_block_length == 0) { | 1257 if (total_block_length == 0) { |
1224 // No extension added. | 1258 // No extension added. |
1225 return 0; | 1259 return 0; |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1358 } | 1392 } |
1359 size_t pos = 0; | 1393 size_t pos = 0; |
1360 const uint8_t len = 0; | 1394 const uint8_t len = 0; |
1361 data_buffer[pos++] = (id << 4) + len; | 1395 data_buffer[pos++] = (id << 4) + len; |
1362 data_buffer[pos++] = ConvertVideoRotationToCVOByte(rotation_); | 1396 data_buffer[pos++] = ConvertVideoRotationToCVOByte(rotation_); |
1363 assert(pos == kVideoRotationLength); | 1397 assert(pos == kVideoRotationLength); |
1364 return kVideoRotationLength; | 1398 return kVideoRotationLength; |
1365 } | 1399 } |
1366 | 1400 |
1367 uint8_t RTPSender::BuildTransportSequenceNumberExtension( | 1401 uint8_t RTPSender::BuildTransportSequenceNumberExtension( |
1368 uint8_t* data_buffer) const { | 1402 uint8_t* data_buffer, |
| 1403 uint16_t sequence_number) const { |
1369 // 0 1 2 | 1404 // 0 1 2 |
1370 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 | 1405 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 |
1371 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | 1406 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
1372 // | ID | L=1 |transport wide sequence number | | 1407 // | ID | L=1 |transport wide sequence number | |
1373 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | 1408 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
1374 | 1409 |
1375 // Get id defined by user. | 1410 // Get id defined by user. |
1376 uint8_t id; | 1411 uint8_t id; |
1377 if (rtp_header_extension_map_.GetId(kRtpExtensionTransportSequenceNumber, | 1412 if (rtp_header_extension_map_.GetId(kRtpExtensionTransportSequenceNumber, |
1378 &id) != 0) { | 1413 &id) != 0) { |
1379 // Not registered. | 1414 // Not registered. |
1380 return 0; | 1415 return 0; |
1381 } | 1416 } |
1382 size_t pos = 0; | 1417 size_t pos = 0; |
1383 const uint8_t len = 1; | 1418 const uint8_t len = 1; |
1384 data_buffer[pos++] = (id << 4) + len; | 1419 data_buffer[pos++] = (id << 4) + len; |
1385 ByteWriter<uint16_t>::WriteBigEndian(data_buffer + pos, | 1420 ByteWriter<uint16_t>::WriteBigEndian(data_buffer + pos, sequence_number); |
1386 transport_sequence_number_); | |
1387 pos += 2; | 1421 pos += 2; |
1388 assert(pos == kTransportSequenceNumberLength); | 1422 assert(pos == kTransportSequenceNumberLength); |
1389 return kTransportSequenceNumberLength; | 1423 return kTransportSequenceNumberLength; |
1390 } | 1424 } |
1391 | 1425 |
1392 bool RTPSender::FindHeaderExtensionPosition(RTPExtensionType type, | 1426 bool RTPSender::FindHeaderExtensionPosition(RTPExtensionType type, |
1393 const uint8_t* rtp_packet, | 1427 const uint8_t* rtp_packet, |
1394 size_t rtp_packet_length, | 1428 size_t rtp_packet_length, |
1395 const RTPHeader& rtp_header, | 1429 const RTPHeader& rtp_header, |
1396 size_t* position) const { | 1430 size_t* position) const { |
(...skipping 22 matching lines...) Expand all Loading... |
1419 (rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs + 1] == 0xDE))) { | 1453 (rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs + 1] == 0xDE))) { |
1420 LOG(LS_WARNING) << "Failed to find extension position for " << type | 1454 LOG(LS_WARNING) << "Failed to find extension position for " << type |
1421 << "as hdr extension not found."; | 1455 << "as hdr extension not found."; |
1422 return false; | 1456 return false; |
1423 } | 1457 } |
1424 | 1458 |
1425 *position = block_pos; | 1459 *position = block_pos; |
1426 return true; | 1460 return true; |
1427 } | 1461 } |
1428 | 1462 |
| 1463 RTPSender::ExtensionStatus RTPSender::VerifyExtension( |
| 1464 RTPExtensionType extension_type, |
| 1465 uint8_t* rtp_packet, |
| 1466 size_t rtp_packet_length, |
| 1467 const RTPHeader& rtp_header, |
| 1468 size_t extension_length_bytes, |
| 1469 size_t* extension_offset) const { |
| 1470 // Get id. |
| 1471 uint8_t id = 0; |
| 1472 if (rtp_header_extension_map_.GetId(extension_type, &id) != 0) |
| 1473 return ExtensionStatus::kNotRegistered; |
| 1474 |
| 1475 size_t block_pos = 0; |
| 1476 if (!FindHeaderExtensionPosition(extension_type, rtp_packet, |
| 1477 rtp_packet_length, rtp_header, &block_pos)) |
| 1478 return ExtensionStatus::kError; |
| 1479 |
| 1480 // Verify that header contains extension. |
| 1481 if (!((rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs] == 0xBE) && |
| 1482 (rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs + 1] == 0xDE))) { |
| 1483 LOG(LS_WARNING) |
| 1484 << "Failed to update absolute send time, hdr extension not found."; |
| 1485 return ExtensionStatus::kError; |
| 1486 } |
| 1487 |
| 1488 // Verify first byte in block. |
| 1489 const uint8_t first_block_byte = (id << 4) + (extension_length_bytes - 2); |
| 1490 if (rtp_packet[block_pos] != first_block_byte) |
| 1491 return ExtensionStatus::kError; |
| 1492 |
| 1493 *extension_offset = block_pos; |
| 1494 return ExtensionStatus::kOk; |
| 1495 } |
| 1496 |
1429 void RTPSender::UpdateTransmissionTimeOffset(uint8_t* rtp_packet, | 1497 void RTPSender::UpdateTransmissionTimeOffset(uint8_t* rtp_packet, |
1430 size_t rtp_packet_length, | 1498 size_t rtp_packet_length, |
1431 const RTPHeader& rtp_header, | 1499 const RTPHeader& rtp_header, |
1432 int64_t time_diff_ms) const { | 1500 int64_t time_diff_ms) const { |
| 1501 size_t offset; |
1433 CriticalSectionScoped cs(send_critsect_.get()); | 1502 CriticalSectionScoped cs(send_critsect_.get()); |
1434 // Get id. | 1503 switch (VerifyExtension(kRtpExtensionTransmissionTimeOffset, rtp_packet, |
1435 uint8_t id = 0; | 1504 rtp_packet_length, rtp_header, |
1436 if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset, | 1505 kTransmissionTimeOffsetLength, &offset)) { |
1437 &id) != 0) { | 1506 case ExtensionStatus::kNotRegistered: |
1438 // Not registered. | 1507 return; |
1439 return; | 1508 case ExtensionStatus::kError: |
| 1509 LOG(LS_WARNING) << "Failed to update transmission time offset."; |
| 1510 return; |
| 1511 case ExtensionStatus::kOk: |
| 1512 break; |
| 1513 default: |
| 1514 RTC_NOTREACHED(); |
1440 } | 1515 } |
1441 | 1516 |
1442 size_t block_pos = 0; | |
1443 if (!FindHeaderExtensionPosition(kRtpExtensionTransmissionTimeOffset, | |
1444 rtp_packet, rtp_packet_length, rtp_header, | |
1445 &block_pos)) { | |
1446 LOG(LS_WARNING) << "Failed to update transmission time offset."; | |
1447 return; | |
1448 } | |
1449 | |
1450 // Verify first byte in block. | |
1451 const uint8_t first_block_byte = (id << 4) + 2; | |
1452 if (rtp_packet[block_pos] != first_block_byte) { | |
1453 LOG(LS_WARNING) << "Failed to update transmission time offset."; | |
1454 return; | |
1455 } | |
1456 // Update transmission offset field (converting to a 90 kHz timestamp). | 1517 // Update transmission offset field (converting to a 90 kHz timestamp). |
1457 ByteWriter<int32_t, 3>::WriteBigEndian(rtp_packet + block_pos + 1, | 1518 ByteWriter<int32_t, 3>::WriteBigEndian(rtp_packet + offset + 1, |
1458 time_diff_ms * 90); // RTP timestamp. | 1519 time_diff_ms * 90); // RTP timestamp. |
1459 } | 1520 } |
1460 | 1521 |
1461 bool RTPSender::UpdateAudioLevel(uint8_t* rtp_packet, | 1522 bool RTPSender::UpdateAudioLevel(uint8_t* rtp_packet, |
1462 size_t rtp_packet_length, | 1523 size_t rtp_packet_length, |
1463 const RTPHeader& rtp_header, | 1524 const RTPHeader& rtp_header, |
1464 bool is_voiced, | 1525 bool is_voiced, |
1465 uint8_t dBov) const { | 1526 uint8_t dBov) const { |
| 1527 size_t offset; |
1466 CriticalSectionScoped cs(send_critsect_.get()); | 1528 CriticalSectionScoped cs(send_critsect_.get()); |
1467 | 1529 |
1468 // Get id. | 1530 switch (VerifyExtension(kRtpExtensionAudioLevel, rtp_packet, |
1469 uint8_t id = 0; | 1531 rtp_packet_length, rtp_header, kAudioLevelLength, |
1470 if (rtp_header_extension_map_.GetId(kRtpExtensionAudioLevel, &id) != 0) { | 1532 &offset)) { |
1471 // Not registered. | 1533 case ExtensionStatus::kNotRegistered: |
1472 return false; | 1534 return false; |
| 1535 case ExtensionStatus::kError: |
| 1536 LOG(LS_WARNING) << "Failed to update audio level."; |
| 1537 return false; |
| 1538 case ExtensionStatus::kOk: |
| 1539 break; |
| 1540 default: |
| 1541 RTC_NOTREACHED(); |
1473 } | 1542 } |
1474 | 1543 |
1475 size_t block_pos = 0; | 1544 rtp_packet[offset + 1] = (is_voiced ? 0x80 : 0x00) + (dBov & 0x7f); |
1476 if (!FindHeaderExtensionPosition(kRtpExtensionAudioLevel, rtp_packet, | |
1477 rtp_packet_length, rtp_header, &block_pos)) { | |
1478 LOG(LS_WARNING) << "Failed to update audio level."; | |
1479 return false; | |
1480 } | |
1481 | |
1482 // Verify first byte in block. | |
1483 const uint8_t first_block_byte = (id << 4) + 0; | |
1484 if (rtp_packet[block_pos] != first_block_byte) { | |
1485 LOG(LS_WARNING) << "Failed to update audio level."; | |
1486 return false; | |
1487 } | |
1488 rtp_packet[block_pos + 1] = (is_voiced ? 0x80 : 0x00) + (dBov & 0x7f); | |
1489 return true; | 1545 return true; |
1490 } | 1546 } |
1491 | 1547 |
1492 bool RTPSender::UpdateVideoRotation(uint8_t* rtp_packet, | 1548 bool RTPSender::UpdateVideoRotation(uint8_t* rtp_packet, |
1493 size_t rtp_packet_length, | 1549 size_t rtp_packet_length, |
1494 const RTPHeader& rtp_header, | 1550 const RTPHeader& rtp_header, |
1495 VideoRotation rotation) const { | 1551 VideoRotation rotation) const { |
| 1552 size_t offset; |
1496 CriticalSectionScoped cs(send_critsect_.get()); | 1553 CriticalSectionScoped cs(send_critsect_.get()); |
1497 | 1554 |
1498 // Get id. | 1555 switch (VerifyExtension(kRtpExtensionVideoRotation, rtp_packet, |
1499 uint8_t id = 0; | 1556 rtp_packet_length, rtp_header, kVideoRotationLength, |
1500 if (rtp_header_extension_map_.GetId(kRtpExtensionVideoRotation, &id) != 0) { | 1557 &offset)) { |
1501 // Not registered. | 1558 case ExtensionStatus::kNotRegistered: |
1502 return false; | 1559 return false; |
| 1560 case ExtensionStatus::kError: |
| 1561 LOG(LS_WARNING) << "Failed to update CVO."; |
| 1562 return false; |
| 1563 case ExtensionStatus::kOk: |
| 1564 break; |
| 1565 default: |
| 1566 RTC_NOTREACHED(); |
1503 } | 1567 } |
1504 | 1568 |
1505 size_t block_pos = 0; | 1569 rtp_packet[offset + 1] = ConvertVideoRotationToCVOByte(rotation); |
1506 if (!FindHeaderExtensionPosition(kRtpExtensionVideoRotation, rtp_packet, | |
1507 rtp_packet_length, rtp_header, &block_pos)) { | |
1508 LOG(LS_WARNING) << "Failed to update video rotation (CVO)."; | |
1509 return false; | |
1510 } | |
1511 // Get length until start of header extension block. | |
1512 int extension_block_pos = | |
1513 rtp_header_extension_map_.GetLengthUntilBlockStartInBytes( | |
1514 kRtpExtensionVideoRotation); | |
1515 if (extension_block_pos < 0) { | |
1516 // The feature is not enabled. | |
1517 return false; | |
1518 } | |
1519 | |
1520 // Verify first byte in block. | |
1521 const uint8_t first_block_byte = (id << 4) + 0; | |
1522 if (rtp_packet[block_pos] != first_block_byte) { | |
1523 LOG(LS_WARNING) << "Failed to update CVO."; | |
1524 return false; | |
1525 } | |
1526 rtp_packet[block_pos + 1] = ConvertVideoRotationToCVOByte(rotation); | |
1527 return true; | 1570 return true; |
1528 } | 1571 } |
1529 | 1572 |
1530 void RTPSender::UpdateAbsoluteSendTime(uint8_t* rtp_packet, | 1573 void RTPSender::UpdateAbsoluteSendTime(uint8_t* rtp_packet, |
1531 size_t rtp_packet_length, | 1574 size_t rtp_packet_length, |
1532 const RTPHeader& rtp_header, | 1575 const RTPHeader& rtp_header, |
1533 int64_t now_ms) const { | 1576 int64_t now_ms) const { |
| 1577 size_t offset; |
1534 CriticalSectionScoped cs(send_critsect_.get()); | 1578 CriticalSectionScoped cs(send_critsect_.get()); |
1535 | 1579 |
1536 // Get id. | 1580 switch (VerifyExtension(kRtpExtensionAbsoluteSendTime, rtp_packet, |
1537 uint8_t id = 0; | 1581 rtp_packet_length, rtp_header, |
1538 if (rtp_header_extension_map_.GetId(kRtpExtensionAbsoluteSendTime, | 1582 kAbsoluteSendTimeLength, &offset)) { |
1539 &id) != 0) { | 1583 case ExtensionStatus::kNotRegistered: |
1540 // Not registered. | 1584 return; |
1541 return; | 1585 case ExtensionStatus::kError: |
| 1586 LOG(LS_WARNING) << "Failed to update absolute send time"; |
| 1587 return; |
| 1588 case ExtensionStatus::kOk: |
| 1589 break; |
| 1590 default: |
| 1591 RTC_NOTREACHED(); |
1542 } | 1592 } |
1543 // Get length until start of header extension block. | 1593 |
1544 int extension_block_pos = | |
1545 rtp_header_extension_map_.GetLengthUntilBlockStartInBytes( | |
1546 kRtpExtensionAbsoluteSendTime); | |
1547 if (extension_block_pos < 0) { | |
1548 // The feature is not enabled. | |
1549 return; | |
1550 } | |
1551 size_t block_pos = | |
1552 kRtpHeaderLength + rtp_header.numCSRCs + extension_block_pos; | |
1553 if (rtp_packet_length < block_pos + kAbsoluteSendTimeLength || | |
1554 rtp_header.headerLength < block_pos + kAbsoluteSendTimeLength) { | |
1555 LOG(LS_WARNING) << "Failed to update absolute send time, invalid length."; | |
1556 return; | |
1557 } | |
1558 // Verify that header contains extension. | |
1559 if (!((rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs] == 0xBE) && | |
1560 (rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs + 1] == 0xDE))) { | |
1561 LOG(LS_WARNING) | |
1562 << "Failed to update absolute send time, hdr extension not found."; | |
1563 return; | |
1564 } | |
1565 // Verify first byte in block. | |
1566 const uint8_t first_block_byte = (id << 4) + 2; | |
1567 if (rtp_packet[block_pos] != first_block_byte) { | |
1568 LOG(LS_WARNING) << "Failed to update absolute send time."; | |
1569 return; | |
1570 } | |
1571 // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit | 1594 // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit |
1572 // fractional part). | 1595 // fractional part). |
1573 ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + block_pos + 1, | 1596 ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + offset + 1, |
1574 ((now_ms << 18) / 1000) & 0x00ffffff); | 1597 ((now_ms << 18) / 1000) & 0x00ffffff); |
1575 } | 1598 } |
1576 | 1599 |
| 1600 uint16_t RTPSender::UpdateTransportSequenceNumber( |
| 1601 uint8_t* rtp_packet, |
| 1602 size_t rtp_packet_length, |
| 1603 const RTPHeader& rtp_header) const { |
| 1604 size_t offset; |
| 1605 CriticalSectionScoped cs(send_critsect_.get()); |
| 1606 |
| 1607 switch (VerifyExtension(kRtpExtensionTransportSequenceNumber, rtp_packet, |
| 1608 rtp_packet_length, rtp_header, |
| 1609 kTransportSequenceNumberLength, &offset)) { |
| 1610 case ExtensionStatus::kNotRegistered: |
| 1611 return 0; |
| 1612 case ExtensionStatus::kError: |
| 1613 LOG(LS_WARNING) << "Failed to update transport sequence number"; |
| 1614 return 0; |
| 1615 case ExtensionStatus::kOk: |
| 1616 break; |
| 1617 default: |
| 1618 RTC_NOTREACHED(); |
| 1619 } |
| 1620 |
| 1621 uint16_t seq = packet_router_->AllocateSequenceNumber(); |
| 1622 BuildTransportSequenceNumberExtension(rtp_packet + offset, seq); |
| 1623 return seq; |
| 1624 } |
| 1625 |
1577 void RTPSender::SetSendingStatus(bool enabled) { | 1626 void RTPSender::SetSendingStatus(bool enabled) { |
1578 if (enabled) { | 1627 if (enabled) { |
1579 uint32_t frequency_hz = SendPayloadFrequency(); | 1628 uint32_t frequency_hz = SendPayloadFrequency(); |
1580 uint32_t RTPtime = RtpUtility::GetCurrentRTP(clock_, frequency_hz); | 1629 uint32_t RTPtime = RtpUtility::GetCurrentRTP(clock_, frequency_hz); |
1581 | 1630 |
1582 // Will be ignored if it's already configured via API. | 1631 // Will be ignored if it's already configured via API. |
1583 SetStartTimestamp(RTPtime, false); | 1632 SetStartTimestamp(RTPtime, false); |
1584 } else { | 1633 } else { |
1585 CriticalSectionScoped lock(send_critsect_.get()); | 1634 CriticalSectionScoped lock(send_critsect_.get()); |
1586 if (!ssrc_forced_) { | 1635 if (!ssrc_forced_) { |
(...skipping 262 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1849 CriticalSectionScoped lock(send_critsect_.get()); | 1898 CriticalSectionScoped lock(send_critsect_.get()); |
1850 | 1899 |
1851 RtpState state; | 1900 RtpState state; |
1852 state.sequence_number = sequence_number_rtx_; | 1901 state.sequence_number = sequence_number_rtx_; |
1853 state.start_timestamp = start_timestamp_; | 1902 state.start_timestamp = start_timestamp_; |
1854 | 1903 |
1855 return state; | 1904 return state; |
1856 } | 1905 } |
1857 | 1906 |
1858 } // namespace webrtc | 1907 } // namespace webrtc |
OLD | NEW |