admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use rtc::CopyOnWriteBuffer::MutableData through webrtc

Browse Source 
where mutable access is required.

Bug: webrtc:12334
Change-Id: I4b2b74f836aaf7f12278c3569d0d49936297716b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/198846
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#32936}
This commit is contained in:
Danil Chapovalov 2021-01-07 15:24:05 +01:00 committed by Commit Bot
parent da06e8f6bd
commit e15dc58f32
27 changed files with 99 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
media/base/fake_network_interface.h
View File

@ -129,7 +129,8 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
rtp_packets_.push_back(*packet); rtp_packets_.push_back(*packet);
if (conf_) { if (conf_) {
for (size_t i = 0; i < conf_sent_ssrcs_.size(); ++i) { for (size_t i = 0; i < conf_sent_ssrcs_.size(); ++i) {
if (!SetRtpSsrc(packet->data(), packet->size(), conf_sent_ssrcs_[i])) { if (!SetRtpSsrc(packet->MutableData(), packet->size(),
conf_sent_ssrcs_[i])) {
return false; return false;
} }
PostMessage(ST_RTP, *packet); PostMessage(ST_RTP, *packet);

2
media/base/rtp_data_engine.cc
View File

@ -312,7 +312,7 @@ bool RtpDataMediaChannel::SendData(const SendDataParams& params,
&header.timestamp); &header.timestamp);
rtc::CopyOnWriteBuffer packet(kMinRtpPacketLen, packet_len); rtc::CopyOnWriteBuffer packet(kMinRtpPacketLen, packet_len);
if (!SetRtpHeader(packet.data(), packet.size(), header)) { if (!SetRtpHeader(packet.MutableData(), packet.size(), header)) {
return false; return false;
} }
packet.AppendData(kReservedSpace); packet.AppendData(kReservedSpace);

2
media/engine/webrtc_video_engine_unittest.cc
View File

@ -2050,7 +2050,7 @@ TEST_F(WebRtcVideoChannelBaseTest, SetSink) {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
rtc::CopyOnWriteBuffer packet1(data1, sizeof(data1)); rtc::CopyOnWriteBuffer packet1(data1, sizeof(data1));
rtc::SetBE32(packet1.data() + 8, kSsrc); rtc::SetBE32(packet1.MutableData() + 8, kSsrc);
channel_->SetDefaultSink(NULL); channel_->SetDefaultSink(NULL);
EXPECT_TRUE(SetDefaultCodec()); EXPECT_TRUE(SetDefaultCodec());
EXPECT_TRUE(SetSend(true)); EXPECT_TRUE(SetSend(true));

8
media/sctp/sctp_transport.cc
View File

@ -1136,14 +1136,14 @@ void SctpTransport::OnPacketFromSctpToNetwork(
} }
int SctpTransport::InjectDataOrNotificationFromSctpForTesting( int SctpTransport::InjectDataOrNotificationFromSctpForTesting(
void* data, const void* data,
size_t length, size_t length,
struct sctp_rcvinfo rcv, struct sctp_rcvinfo rcv,
int flags) { int flags) {
return OnDataOrNotificationFromSctp(data, length, rcv, flags); return OnDataOrNotificationFromSctp(data, length, rcv, flags);
} }
int SctpTransport::OnDataOrNotificationFromSctp(void* data, int SctpTransport::OnDataOrNotificationFromSctp(const void* data,
size_t length, size_t length,
struct sctp_rcvinfo rcv, struct sctp_rcvinfo rcv,
int flags) { int flags) {
@ -1166,7 +1166,7 @@ int SctpTransport::OnDataOrNotificationFromSctp(void* data,
<< " length=" << length; << " length=" << length;
// Copy and dispatch asynchronously // Copy and dispatch asynchronously
rtc::CopyOnWriteBuffer notification(reinterpret_cast<uint8_t*>(data), rtc::CopyOnWriteBuffer notification(reinterpret_cast<const uint8_t*>(data),
length); length);
network_thread_->PostTask(ToQueuedTask( network_thread_->PostTask(ToQueuedTask(
task_safety_, [this, notification = std::move(notification)]() { task_safety_, [this, notification = std::move(notification)]() {
@ -1216,7 +1216,7 @@ int SctpTransport::OnDataOrNotificationFromSctp(void* data,
params.timestamp = 0; params.timestamp = 0;
// Append the chunk's data to the message buffer // Append the chunk's data to the message buffer
partial_incoming_message_.AppendData(reinterpret_cast<uint8_t*>(data), partial_incoming_message_.AppendData(reinterpret_cast<const uint8_t*>(data),
length); length);
partial_params_ = params; partial_params_ = params;
partial_flags_ = flags; partial_flags_ = flags;

4
media/sctp/sctp_transport.h
View File

@ -96,7 +96,7 @@ class SctpTransport : public SctpTransportInternal,
void set_debug_name_for_testing(const char* debug_name) override { void set_debug_name_for_testing(const char* debug_name) override {
debug_name_ = debug_name; debug_name_ = debug_name;
} }
int InjectDataOrNotificationFromSctpForTesting(void* data, int InjectDataOrNotificationFromSctpForTesting(const void* data,
size_t length, size_t length,
struct sctp_rcvinfo rcv, struct sctp_rcvinfo rcv,
int flags); int flags);
@ -182,7 +182,7 @@ class SctpTransport : public SctpTransportInternal,
// Called on the SCTP thread. // Called on the SCTP thread.
// Flags are standard socket API flags (RFC 6458). // Flags are standard socket API flags (RFC 6458).
int OnDataOrNotificationFromSctp(void* data, int OnDataOrNotificationFromSctp(const void* data,
size_t length, size_t length,
struct sctp_rcvinfo rcv, struct sctp_rcvinfo rcv,
int flags); int flags);

2
media/sctp/sctp_transport_unittest.cc
View File

@ -589,7 +589,7 @@ TEST_P(SctpTransportTestWithOrdered, SignalReadyToSendDataAfterBlocked) {
params.sid = 1; params.sid = 1;
params.ordered = GetParam(); params.ordered = GetParam();
rtc::CopyOnWriteBuffer buf(1024); rtc::CopyOnWriteBuffer buf(1024);
memset(buf.data<uint8_t>(), 0, 1024); memset(buf.MutableData(), 0, 1024);
SendDataResult result; SendDataResult result;
size_t message_count = 0; size_t message_count = 0;
for (; message_count < kMaxMessages; ++message_count) { for (; message_count < kMaxMessages; ++message_count) {

12
modules/rtp_rtcp/source/fec_test_helper.cc
View File

@ -57,7 +57,7 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
media_packet->data.SetSize( media_packet->data.SetSize(
random_->Rand(min_packet_size_, max_packet_size_)); random_->Rand(min_packet_size_, max_packet_size_));
uint8_t* data = media_packet->data.data(); uint8_t* data = media_packet->data.MutableData();
// Generate random values for the first 2 bytes // Generate random values for the first 2 bytes
data[0] = random_->Rand<uint8_t>(); data[0] = random_->Rand<uint8_t>();
data[1] = random_->Rand<uint8_t>(); data[1] = random_->Rand<uint8_t>();
@ -88,7 +88,7 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
// Last packet, set marker bit. // Last packet, set marker bit.
ForwardErrorCorrection::Packet* media_packet = media_packets.back().get(); ForwardErrorCorrection::Packet* media_packet = media_packets.back().get();
RTC_DCHECK(media_packet); RTC_DCHECK(media_packet);
media_packet->data[1] |= 0x80; media_packet->data.MutableData()[1] |= 0x80;
next_seq_num_ = seq_num; next_seq_num_ = seq_num;
@ -122,7 +122,7 @@ std::unique_ptr<AugmentedPacket> AugmentedPacketGenerator::NextPacket(
std::unique_ptr<AugmentedPacket> packet(new AugmentedPacket()); std::unique_ptr<AugmentedPacket> packet(new AugmentedPacket());
packet->data.SetSize(length + kRtpHeaderSize); packet->data.SetSize(length + kRtpHeaderSize);
uint8_t* data = packet->data.data(); uint8_t* data = packet->data.MutableData();
for (size_t i = 0; i < length; ++i) for (size_t i = 0; i < length; ++i)
data[i + kRtpHeaderSize] = offset + i; data[i + kRtpHeaderSize] = offset + i;
packet->data.SetSize(length + kRtpHeaderSize); packet->data.SetSize(length + kRtpHeaderSize);
@ -132,7 +132,7 @@ std::unique_ptr<AugmentedPacket> AugmentedPacketGenerator::NextPacket(
packet->header.sequenceNumber = seq_num_; packet->header.sequenceNumber = seq_num_;
packet->header.timestamp = timestamp_; packet->header.timestamp = timestamp_;
packet->header.ssrc = ssrc_; packet->header.ssrc = ssrc_;
WriteRtpHeader(packet->header, packet->data.data()); WriteRtpHeader(packet->header, data);
++seq_num_; ++seq_num_;
--num_packets_; --num_packets_;
@ -171,8 +171,8 @@ std::unique_ptr<AugmentedPacket> FlexfecPacketGenerator::BuildFlexfecPacket(
std::unique_ptr<AugmentedPacket> packet_with_rtp_header( std::unique_ptr<AugmentedPacket> packet_with_rtp_header(
new AugmentedPacket()); new AugmentedPacket());
packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.data.size()); packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.data.size());
WriteRtpHeader(header, packet_with_rtp_header->data.data()); WriteRtpHeader(header, packet_with_rtp_header->data.MutableData());
memcpy(packet_with_rtp_header->data.data() + kRtpHeaderSize, memcpy(packet_with_rtp_header->data.MutableData() + kRtpHeaderSize,
packet.data.cdata(), packet.data.size()); packet.data.cdata(), packet.data.size());
return packet_with_rtp_header; return packet_with_rtp_header;

7
modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
View File

@ -85,7 +85,7 @@ bool FlexfecHeaderReader::ReadFecHeader(
RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet.";
return false; return false;
} }
uint8_t* const data = fec_packet->pkt->data.data(); uint8_t* const data = fec_packet->pkt->data.MutableData();
bool r_bit = (data[0] & 0x80) != 0; bool r_bit = (data[0] & 0x80) != 0;
if (r_bit) { if (r_bit) {
RTC_LOG(LS_INFO) RTC_LOG(LS_INFO)
@ -249,7 +249,7 @@ void FlexfecHeaderWriter::FinalizeFecHeader(
const uint8_t* packet_mask, const uint8_t* packet_mask,
size_t packet_mask_size, size_t packet_mask_size,
ForwardErrorCorrection::Packet* fec_packet) const { ForwardErrorCorrection::Packet* fec_packet) const {
uint8_t* data = fec_packet->data.data(); uint8_t* data = fec_packet->data.MutableData();
data[0] &= 0x7f; // Clear R bit. data[0] &= 0x7f; // Clear R bit.
data[0] &= 0xbf; // Clear F bit. data[0] &= 0xbf; // Clear F bit.
ByteWriter<uint8_t>::WriteBigEndian(&data[8], kSsrcCount); ByteWriter<uint8_t>::WriteBigEndian(&data[8], kSsrcCount);
@ -260,8 +260,7 @@ void FlexfecHeaderWriter::FinalizeFecHeader(
// //
// We treat the mask parts as unsigned integers with host order endianness // We treat the mask parts as unsigned integers with host order endianness
// in order to simplify the bit shifting between bytes. // in order to simplify the bit shifting between bytes.
uint8_t* const written_packet_mask = uint8_t* const written_packet_mask = data + kPacketMaskOffset;
fec_packet->data.data() + kPacketMaskOffset;
if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet) { if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet) {
// The packet mask is 48 bits long. // The packet mask is 48 bits long.
uint16_t tmp_mask_part0 = uint16_t tmp_mask_part0 =

12
modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc
View File

@ -78,8 +78,9 @@ rtc::scoped_refptr<Packet> WriteHeader(const uint8_t* packet_mask,
FlexfecHeaderWriter writer; FlexfecHeaderWriter writer;
rtc::scoped_refptr<Packet> written_packet(new Packet()); rtc::scoped_refptr<Packet> written_packet(new Packet());
written_packet->data.SetSize(kMediaPacketLength); written_packet->data.SetSize(kMediaPacketLength);
uint8_t* data = written_packet->data.MutableData();
for (size_t i = 0; i < written_packet->data.size(); ++i) { for (size_t i = 0; i < written_packet->data.size(); ++i) {
written_packet->data[i] = i; // Actual content doesn't matter. data[i] = i; // Actual content doesn't matter.
} }
writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask,
packet_mask_size, written_packet.get()); packet_mask_size, written_packet.get());
@ -328,8 +329,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit0Set) {
constexpr uint8_t kUlpfecPacketMask[] = {0x11, 0x02}; constexpr uint8_t kUlpfecPacketMask[] = {0x11, 0x02};
Packet written_packet; Packet written_packet;
written_packet.data.SetSize(kMediaPacketLength); written_packet.data.SetSize(kMediaPacketLength);
uint8_t* data = written_packet.data.MutableData();
for (size_t i = 0; i < written_packet.data.size(); ++i) { for (size_t i = 0; i < written_packet.data.size(); ++i) {
written_packet.data[i] = i; data[i] = i;
} }
FlexfecHeaderWriter writer; FlexfecHeaderWriter writer;
@ -346,8 +348,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit1Set) {
constexpr uint8_t kUlpfecPacketMask[] = {0x91, 0x02, 0x08, 0x44, 0x00, 0x84}; constexpr uint8_t kUlpfecPacketMask[] = {0x91, 0x02, 0x08, 0x44, 0x00, 0x84};
Packet written_packet; Packet written_packet;
written_packet.data.SetSize(kMediaPacketLength); written_packet.data.SetSize(kMediaPacketLength);
uint8_t* data = written_packet.data.MutableData();
for (size_t i = 0; i < written_packet.data.size(); ++i) { for (size_t i = 0; i < written_packet.data.size(); ++i) {
written_packet.data[i] = i; data[i] = i;
} }
FlexfecHeaderWriter writer; FlexfecHeaderWriter writer;
@ -368,8 +371,9 @@ TEST(FlexfecHeaderWriterTest, FinalizesHeaderWithKBit2Set) {
constexpr uint8_t kUlpfecPacketMask[] = {0x22, 0x22, 0x44, 0x44, 0x44, 0x41}; constexpr uint8_t kUlpfecPacketMask[] = {0x22, 0x22, 0x44, 0x44, 0x44, 0x41};
Packet written_packet; Packet written_packet;
written_packet.data.SetSize(kMediaPacketLength); written_packet.data.SetSize(kMediaPacketLength);
uint8_t* data = written_packet.data.MutableData();
for (size_t i = 0; i < written_packet.data.size(); ++i) { for (size_t i = 0; i < written_packet.data.size(); ++i) {
written_packet.data[i] = i; data[i] = i;
} }
FlexfecHeaderWriter writer; FlexfecHeaderWriter writer;

16
modules/rtp_rtcp/source/flexfec_receiver_unittest.cc
View File

@ -165,10 +165,10 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) {
PacketizeFrame(kNumMediaPackets, 0, &media_packets); PacketizeFrame(kNumMediaPackets, 0, &media_packets);
auto& media_packet = media_packets.front(); auto& media_packet = media_packets.front();
// Corrupt the SSRC. // Corrupt the SSRC.
media_packet->data[8] = 0; media_packet->data.MutableData()[8] = 0;
media_packet->data[9] = 1; media_packet->data.MutableData()[9] = 1;
media_packet->data[10] = 2; media_packet->data.MutableData()[10] = 2;
media_packet->data[11] = 3; media_packet->data.MutableData()[11] = 3;
EXPECT_FALSE(receiver_.AddReceivedPacket(ParsePacket(*media_packet))); EXPECT_FALSE(receiver_.AddReceivedPacket(ParsePacket(*media_packet)));
} }
@ -183,10 +183,10 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) {
const auto& media_packet = media_packets.front(); const auto& media_packet = media_packets.front();
auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front()); auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
// Corrupt the SSRC. // Corrupt the SSRC.
fec_packet->data[8] = 4; fec_packet->data.MutableData()[8] = 4;
fec_packet->data[9] = 5; fec_packet->data.MutableData()[9] = 5;
fec_packet->data[10] = 6; fec_packet->data.MutableData()[10] = 6;
fec_packet->data[11] = 7; fec_packet->data.MutableData()[11] = 7;
std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> received_packet = std::unique_ptr<ForwardErrorCorrection::ReceivedPacket> received_packet =
receiver_.AddReceivedPacket(ParsePacket(*media_packet)); receiver_.AddReceivedPacket(ParsePacket(*media_packet));

20
modules/rtp_rtcp/source/forward_error_correction.cc
View File

@ -151,7 +151,7 @@ int ForwardErrorCorrection::EncodeFec(const PacketList& media_packets,
} }
for (int i = 0; i < num_fec_packets; ++i) { for (int i = 0; i < num_fec_packets; ++i) {
generated_fec_packets_[i].data.EnsureCapacity(IP_PACKET_SIZE); generated_fec_packets_[i].data.EnsureCapacity(IP_PACKET_SIZE);
memset(generated_fec_packets_[i].data.data(), 0, IP_PACKET_SIZE); memset(generated_fec_packets_[i].data.MutableData(), 0, IP_PACKET_SIZE);
// Use this as a marker for untouched packets. // Use this as a marker for untouched packets.
generated_fec_packets_[i].data.SetSize(0); generated_fec_packets_[i].data.SetSize(0);
fec_packets->push_back(&generated_fec_packets_[i]); fec_packets->push_back(&generated_fec_packets_[i]);
@ -231,7 +231,7 @@ void ForwardErrorCorrection::GenerateFecPayloads(
fec_packet->data.SetSize(fec_packet_length); fec_packet->data.SetSize(fec_packet_length);
} }
if (first_protected_packet) { if (first_protected_packet) {
uint8_t* data = fec_packet->data.data(); uint8_t* data = fec_packet->data.MutableData();
// Write P, X, CC, M, and PT recovery fields. // Write P, X, CC, M, and PT recovery fields.
// Note that bits 0, 1, and 16 are overwritten in FinalizeFecHeaders. // Note that bits 0, 1, and 16 are overwritten in FinalizeFecHeaders.
memcpy(&data[0], &media_packet_data[0], 2); memcpy(&data[0], &media_packet_data[0], 2);
@ -567,11 +567,11 @@ bool ForwardErrorCorrection::StartPacketRecovery(
// Copy bytes corresponding to minimum RTP header size. // Copy bytes corresponding to minimum RTP header size.
// Note that the sequence number and SSRC fields will be overwritten // Note that the sequence number and SSRC fields will be overwritten
// at the end of packet recovery. // at the end of packet recovery.
memcpy(recovered_packet->pkt->data.data(), fec_packet.pkt->data.cdata(), memcpy(recovered_packet->pkt->data.MutableData(),
kRtpHeaderSize); fec_packet.pkt->data.cdata(), kRtpHeaderSize);
// Copy remaining FEC payload. // Copy remaining FEC payload.
if (fec_packet.protection_length > 0) { if (fec_packet.protection_length > 0) {
memcpy(recovered_packet->pkt->data.data() + kRtpHeaderSize, memcpy(recovered_packet->pkt->data.MutableData() + kRtpHeaderSize,
fec_packet.pkt->data.cdata() + fec_packet.fec_header_size, fec_packet.pkt->data.cdata() + fec_packet.fec_header_size,
fec_packet.protection_length); fec_packet.protection_length);
} }
@ -581,7 +581,7 @@ bool ForwardErrorCorrection::StartPacketRecovery(
bool ForwardErrorCorrection::FinishPacketRecovery( bool ForwardErrorCorrection::FinishPacketRecovery(
const ReceivedFecPacket& fec_packet, const ReceivedFecPacket& fec_packet,
RecoveredPacket* recovered_packet) { RecoveredPacket* recovered_packet) {
uint8_t* data = recovered_packet->pkt->data.data(); uint8_t* data = recovered_packet->pkt->data.MutableData();
// Set the RTP version to 2. // Set the RTP version to 2.
data[0] |= 0x80; // Set the 1st bit. data[0] |= 0x80; // Set the 1st bit.
data[0] &= 0xbf; // Clear the 2nd bit. data[0] &= 0xbf; // Clear the 2nd bit.
@ -603,7 +603,7 @@ bool ForwardErrorCorrection::FinishPacketRecovery(
} }
void ForwardErrorCorrection::XorHeaders(const Packet& src, Packet* dst) { void ForwardErrorCorrection::XorHeaders(const Packet& src, Packet* dst) {
uint8_t* dst_data = dst->data.data(); uint8_t* dst_data = dst->data.MutableData();
const uint8_t* src_data = src.data.cdata(); const uint8_t* src_data = src.data.cdata();
// XOR the first 2 bytes of the header: V, P, X, CC, M, PT fields. // XOR the first 2 bytes of the header: V, P, X, CC, M, PT fields.
dst_data[0] ^= src_data[0]; dst_data[0] ^= src_data[0];
@ -635,7 +635,7 @@ void ForwardErrorCorrection::XorPayloads(const Packet& src,
if (dst_offset + payload_length > dst->data.size()) { if (dst_offset + payload_length > dst->data.size()) {
dst->data.SetSize(dst_offset + payload_length); dst->data.SetSize(dst_offset + payload_length);
} }
uint8_t* dst_data = dst->data.data(); uint8_t* dst_data = dst->data.MutableData();
const uint8_t* src_data = src.data.cdata(); const uint8_t* src_data = src.data.cdata();
for (size_t i = 0; i < payload_length; ++i) { for (size_t i = 0; i < payload_length; ++i) {
dst_data[dst_offset + i] ^= src_data[kRtpHeaderSize + i]; dst_data[dst_offset + i] ^= src_data[kRtpHeaderSize + i];
@ -731,11 +731,11 @@ void ForwardErrorCorrection::DiscardOldRecoveredPackets(
RTC_DCHECK_LE(recovered_packets->size(), max_media_packets); RTC_DCHECK_LE(recovered_packets->size(), max_media_packets);
} }
uint16_t ForwardErrorCorrection::ParseSequenceNumber(uint8_t* packet) { uint16_t ForwardErrorCorrection::ParseSequenceNumber(const uint8_t* packet) {
return (packet[2] << 8) + packet[3]; return (packet[2] << 8) + packet[3];
} }
uint32_t ForwardErrorCorrection::ParseSsrc(uint8_t* packet) { uint32_t ForwardErrorCorrection::ParseSsrc(const uint8_t* packet) {
return (packet[8] << 24) + (packet[9] << 16) + (packet[10] << 8) + packet[11]; return (packet[8] << 24) + (packet[9] << 16) + (packet[10] << 8) + packet[11];
} }

4
modules/rtp_rtcp/source/forward_error_correction.h
View File

@ -235,8 +235,8 @@ class ForwardErrorCorrection {
// TODO(brandtr): Remove these functions when the Packet classes // TODO(brandtr): Remove these functions when the Packet classes
// have been refactored. // have been refactored.
static uint16_t ParseSequenceNumber(uint8_t* packet); static uint16_t ParseSequenceNumber(const uint8_t* packet);
static uint32_t ParseSsrc(uint8_t* packet); static uint32_t ParseSsrc(const uint8_t* packet);
protected: protected:
ForwardErrorCorrection(std::unique_ptr<FecHeaderReader> fec_header_reader, ForwardErrorCorrection(std::unique_ptr<FecHeaderReader> fec_header_reader,

23
modules/rtp_rtcp/source/rtp_fec_unittest.cc
View File

@ -127,7 +127,7 @@ void RtpFecTest<ForwardErrorCorrectionType>::ReceivedPackets(
// For media packets, the sequence number is obtained from the // For media packets, the sequence number is obtained from the
// RTP header as written by MediaPacketGenerator::ConstructMediaPackets. // RTP header as written by MediaPacketGenerator::ConstructMediaPackets.
received_packet->seq_num = received_packet->seq_num =
ByteReader<uint16_t>::ReadBigEndian(&packet->data[2]); ByteReader<uint16_t>::ReadBigEndian(packet->data.data() + 2);
} else { } else {
received_packet->ssrc = ForwardErrorCorrectionType::kFecSsrc; received_packet->ssrc = ForwardErrorCorrectionType::kFecSsrc;
// For FEC packets, we simulate the sequence numbers differently // For FEC packets, we simulate the sequence numbers differently
@ -222,10 +222,10 @@ TYPED_TEST(RtpFecTest, WillProtectMediaPacketsWithLargeSequenceNumberGap) {
this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
// Create |kMaxMediaPackets - 1| sequence number difference. // Create |kMaxMediaPackets - 1| sequence number difference.
ByteWriter<uint16_t>::WriteBigEndian(&this->media_packets_.front()->data[2], ByteWriter<uint16_t>::WriteBigEndian(
1); this->media_packets_.front()->data.MutableData() + 2, 1);
ByteWriter<uint16_t>::WriteBigEndian(&this->media_packets_.back()->data[2], ByteWriter<uint16_t>::WriteBigEndian(
kMaxMediaPackets); this->media_packets_.back()->data.MutableData() + 2, kMaxMediaPackets);
EXPECT_EQ( EXPECT_EQ(
0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, 0, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
@ -245,10 +245,11 @@ TYPED_TEST(RtpFecTest,
this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
// Create |kMaxMediaPackets| sequence number difference. // Create |kMaxMediaPackets| sequence number difference.
ByteWriter<uint16_t>::WriteBigEndian(&this->media_packets_.front()->data[2], ByteWriter<uint16_t>::WriteBigEndian(
1); this->media_packets_.front()->data.MutableData() + 2, 1);
ByteWriter<uint16_t>::WriteBigEndian(&this->media_packets_.back()->data[2], ByteWriter<uint16_t>::WriteBigEndian(
kMaxMediaPackets + 1); this->media_packets_.back()->data.MutableData() + 2,
kMaxMediaPackets + 1);
EXPECT_EQ( EXPECT_EQ(
-1, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor, -1, this->fec_.EncodeFec(this->media_packets_, kProtectionFactor,
@ -526,9 +527,9 @@ TEST_F(RtpFecTestFlexfecOnly, FecRecoveryWithSeqNumGapOneFrameNoRecovery) {
// Overwrite the sequence numbers generated by ConstructMediaPackets, // Overwrite the sequence numbers generated by ConstructMediaPackets,
// to make sure that we do have a wrap. // to make sure that we do have a wrap.
auto it = this->generated_fec_packets_.begin(); auto it = this->generated_fec_packets_.begin();
ByteWriter<uint16_t>::WriteBigEndian(&(*it)->data[2], 65535); ByteWriter<uint16_t>::WriteBigEndian(&(*it)->data.MutableData()[2], 65535);
++it; ++it;
ByteWriter<uint16_t>::WriteBigEndian(&(*it)->data[2], 0); ByteWriter<uint16_t>::WriteBigEndian(&(*it)->data.MutableData()[2], 0);
// Lose the last two media packets (seq# 65533, 65534). // Lose the last two media packets (seq# 65533, 65534).
memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_)); memset(this->media_loss_mask_, 0, sizeof(this->media_loss_mask_));

6
modules/rtp_rtcp/source/rtp_packet.h
View File

@ -180,8 +180,10 @@ class RtpPacket {
uint16_t SetExtensionLengthMaybeAddZeroPadding(size_t extensions_offset); uint16_t SetExtensionLengthMaybeAddZeroPadding(size_t extensions_offset);
uint8_t* WriteAt(size_t offset) { return buffer_.data() + offset; } uint8_t* WriteAt(size_t offset) { return buffer_.MutableData() + offset; }
void WriteAt(size_t offset, uint8_t byte) { buffer_.data()[offset] = byte; } void WriteAt(size_t offset, uint8_t byte) {
buffer_.MutableData()[offset] = byte;
}
const uint8_t* ReadAt(size_t offset) const { return buffer_.data() + offset; } const uint8_t* ReadAt(size_t offset) const { return buffer_.data() + offset; }
// Header. // Header.

4
modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
View File

@ -57,7 +57,7 @@ UlpfecHeaderReader::~UlpfecHeaderReader() = default;
bool UlpfecHeaderReader::ReadFecHeader( bool UlpfecHeaderReader::ReadFecHeader(
ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const { ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const {
uint8_t* data = fec_packet->pkt->data.data(); uint8_t* data = fec_packet->pkt->data.MutableData();
if (fec_packet->pkt->data.size() < kPacketMaskOffset) { if (fec_packet->pkt->data.size() < kPacketMaskOffset) {
return false; // Truncated packet. return false; // Truncated packet.
} }
@ -108,7 +108,7 @@ void UlpfecHeaderWriter::FinalizeFecHeader(
const uint8_t* packet_mask, const uint8_t* packet_mask,
size_t packet_mask_size, size_t packet_mask_size,
ForwardErrorCorrection::Packet* fec_packet) const { ForwardErrorCorrection::Packet* fec_packet) const {
uint8_t* data = fec_packet->data.data(); uint8_t* data = fec_packet->data.MutableData();
// Set E bit to zero. // Set E bit to zero.
data[0] &= 0x7f; data[0] &= 0x7f;
// Set L bit based on packet mask size. (Note that the packet mask // Set L bit based on packet mask size. (Note that the packet mask

12
modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
View File

@ -53,8 +53,9 @@ std::unique_ptr<Packet> WriteHeader(const uint8_t* packet_mask,
UlpfecHeaderWriter writer; UlpfecHeaderWriter writer;
std::unique_ptr<Packet> written_packet(new Packet()); std::unique_ptr<Packet> written_packet(new Packet());
written_packet->data.SetSize(kMediaPacketLength); written_packet->data.SetSize(kMediaPacketLength);
uint8_t* data = written_packet->data.MutableData();
for (size_t i = 0; i < written_packet->data.size(); ++i) { for (size_t i = 0; i < written_packet->data.size(); ++i) {
written_packet->data[i] = i; // Actual content doesn't matter. data[i] = i; // Actual content doesn't matter.
} }
writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask,
packet_mask_size, written_packet.get()); packet_mask_size, written_packet.get());
@ -85,7 +86,8 @@ void VerifyHeaders(size_t expected_fec_header_size,
EXPECT_EQ(written_packet.data.size() - expected_fec_header_size, EXPECT_EQ(written_packet.data.size() - expected_fec_header_size,
read_packet.protection_length); read_packet.protection_length);
EXPECT_EQ(0, memcmp(expected_packet_mask, EXPECT_EQ(0, memcmp(expected_packet_mask,
&read_packet.pkt->data[read_packet.packet_mask_offset], read_packet.pkt->data.MutableData() +
read_packet.packet_mask_offset,
read_packet.packet_mask_size)); read_packet.packet_mask_size));
// Verify that the call to ReadFecHeader did not tamper with the payload. // Verify that the call to ReadFecHeader did not tamper with the payload.
EXPECT_EQ(0, memcmp(written_packet.data.data() + expected_fec_header_size, EXPECT_EQ(0, memcmp(written_packet.data.data() + expected_fec_header_size,
@ -147,8 +149,9 @@ TEST(UlpfecHeaderWriterTest, FinalizesSmallHeader) {
auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd); auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
Packet written_packet; Packet written_packet;
written_packet.data.SetSize(kMediaPacketLength); written_packet.data.SetSize(kMediaPacketLength);
uint8_t* data = written_packet.data.MutableData();
for (size_t i = 0; i < written_packet.data.size(); ++i) { for (size_t i = 0; i < written_packet.data.size(); ++i) {
written_packet.data[i] = i; data[i] = i;
} }
UlpfecHeaderWriter writer; UlpfecHeaderWriter writer;
@ -171,8 +174,9 @@ TEST(UlpfecHeaderWriterTest, FinalizesLargeHeader) {
auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd); auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
Packet written_packet; Packet written_packet;
written_packet.data.SetSize(kMediaPacketLength); written_packet.data.SetSize(kMediaPacketLength);
uint8_t* data = written_packet.data.MutableData();
for (size_t i = 0; i < written_packet.data.size(); ++i) { for (size_t i = 0; i < written_packet.data.size(); ++i) {
written_packet.data[i] = i; data[i] = i;
} }
UlpfecHeaderWriter writer; UlpfecHeaderWriter writer;

5
modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
View File

@ -135,8 +135,9 @@ bool UlpfecReceiverImpl::AddReceivedRedPacket(
received_packet->pkt->data.SetData(rtp_packet.data(), received_packet->pkt->data.SetData(rtp_packet.data(),
rtp_packet.headers_size()); rtp_packet.headers_size());
// Set payload type. // Set payload type.
received_packet->pkt->data[1] &= 0x80; // Reset RED payload type. uint8_t& payload_type_byte = received_packet->pkt->data.MutableData()[1];
received_packet->pkt->data[1] += payload_type; // Set media payload type. payload_type_byte &= 0x80; // Reset RED payload type.
payload_type_byte += payload_type; // Set media payload type.
// Copy payload data. // Copy payload data.
received_packet->pkt->data.AppendData(red_payload.data(), received_packet->pkt->data.AppendData(red_payload.data(),
red_payload.size()); red_payload.size());

2
modules/rtp_rtcp/source/ulpfec_receiver_unittest.cc
View File

@ -158,7 +158,7 @@ void UlpfecReceiverTest::InjectGarbagePacketLength(size_t fec_garbage_offset) {
std::list<ForwardErrorCorrection::Packet*> fec_packets; std::list<ForwardErrorCorrection::Packet*> fec_packets;
EncodeFec(media_packets, kNumFecPackets, &fec_packets); EncodeFec(media_packets, kNumFecPackets, &fec_packets);
ByteWriter<uint16_t>::WriteBigEndian( ByteWriter<uint16_t>::WriteBigEndian(
&fec_packets.front()->data[fec_garbage_offset], 0x4711); fec_packets.front()->data.MutableData() + fec_garbage_offset, 0x4711);
// Inject first media packet, then first FEC packet, skipping the second media // Inject first media packet, then first FEC packet, skipping the second media
// packet to cause a recovery from the FEC packet. // packet to cause a recovery from the FEC packet.

2
modules/rtp_rtcp/source/video_rtp_depacketizer_h264.cc
View File

@ -264,7 +264,7 @@ absl::optional<VideoRtpDepacketizer::ParsedRtpPayload> ParseFuaNalu(
uint8_t original_nal_header = fnri | original_nal_type; uint8_t original_nal_header = fnri | original_nal_type;
rtp_payload = rtp_payload =
rtp_payload.Slice(kNalHeaderSize, rtp_payload.size() - kNalHeaderSize); rtp_payload.Slice(kNalHeaderSize, rtp_payload.size() - kNalHeaderSize);
rtp_payload[0] = original_nal_header; rtp_payload.MutableData()[0] = original_nal_header;
parsed_payload->video_payload = std::move(rtp_payload); parsed_payload->video_payload = std::move(rtp_payload);
} else { } else {
parsed_payload->video_payload = parsed_payload->video_payload =

8
modules/rtp_rtcp/test/testFec/test_fec.cc
View File

@ -254,7 +254,7 @@ void RunTest(bool use_flexfec) {
random.Rand(kMinPacketSize, kMaxPacketSize); random.Rand(kMinPacketSize, kMaxPacketSize);
media_packet->data.SetSize(packet_length); media_packet->data.SetSize(packet_length);
uint8_t* data = media_packet->data.data(); uint8_t* data = media_packet->data.MutableData();
// Generate random values for the first 2 bytes. // Generate random values for the first 2 bytes.
data[0] = random.Rand<uint8_t>(); data[0] = random.Rand<uint8_t>();
data[1] = random.Rand<uint8_t>(); data[1] = random.Rand<uint8_t>();
@ -285,7 +285,7 @@ void RunTest(bool use_flexfec) {
media_packet_list.push_back(std::move(media_packet)); media_packet_list.push_back(std::move(media_packet));
seq_num++; seq_num++;
} }
media_packet_list.back()->data[1] |= 0x80; media_packet_list.back()->data.MutableData()[1] |= 0x80;
ASSERT_EQ(0, fec->EncodeFec(media_packet_list, protection_factor, ASSERT_EQ(0, fec->EncodeFec(media_packet_list, protection_factor,
num_imp_packets, kUseUnequalProtection, num_imp_packets, kUseUnequalProtection,
@ -312,8 +312,8 @@ void RunTest(bool use_flexfec) {
received_packet->pkt = new ForwardErrorCorrection::Packet(); received_packet->pkt = new ForwardErrorCorrection::Packet();
received_packet->pkt->data = media_packet->data; received_packet->pkt->data = media_packet->data;
received_packet->ssrc = media_ssrc; received_packet->ssrc = media_ssrc;
received_packet->seq_num = received_packet->seq_num = ByteReader<uint16_t>::ReadBigEndian(
ByteReader<uint16_t>::ReadBigEndian(&media_packet->data[2]); media_packet->data.data() + 2);
received_packet->is_fec = false; received_packet->is_fec = false;
received_packet_list.push_back(std::move(received_packet)); received_packet_list.push_back(std::move(received_packet));
} }

2
p2p/base/dtls_transport_unittest.cc
View File

@ -52,7 +52,7 @@ void SetRemoteFingerprintFromCert(
std::unique_ptr<rtc::SSLFingerprint> fingerprint = std::unique_ptr<rtc::SSLFingerprint> fingerprint =
rtc::SSLFingerprint::CreateFromCertificate(*cert); rtc::SSLFingerprint::CreateFromCertificate(*cert);
if (modify_digest) { if (modify_digest) {
++fingerprint->digest[0]; ++fingerprint->digest.MutableData()[0];
} }
// Even if digest is verified to be incorrect, should fail asynchrnously. // Even if digest is verified to be incorrect, should fail asynchrnously.
EXPECT_TRUE(transport->SetRemoteFingerprint( EXPECT_TRUE(transport->SetRemoteFingerprint(

6
pc/data_channel_unittest.cc
View File

@ -546,7 +546,7 @@ TEST_F(SctpDataChannelTest, ClosedWhenSendBufferFull) {
SetChannelReady(); SetChannelReady();
rtc::CopyOnWriteBuffer buffer(1024); rtc::CopyOnWriteBuffer buffer(1024);
memset(buffer.data(), 0, buffer.size()); memset(buffer.MutableData(), 0, buffer.size());
webrtc::DataBuffer packet(buffer, true); webrtc::DataBuffer packet(buffer, true);
provider_->set_send_blocked(true); provider_->set_send_blocked(true);
@ -581,7 +581,7 @@ TEST_F(SctpDataChannelTest, ClosedOnTransportError) {
TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) { TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) {
SetChannelReady(); SetChannelReady();
rtc::CopyOnWriteBuffer buffer(1024); rtc::CopyOnWriteBuffer buffer(1024);
memset(buffer.data(), 0, buffer.size()); memset(buffer.MutableData(), 0, buffer.size());
cricket::ReceiveDataParams params; cricket::ReceiveDataParams params;
params.ssrc = 0; params.ssrc = 0;
@ -623,7 +623,7 @@ TEST_F(SctpDataChannelTest, TransportDestroyedWhileDataBuffered) {
SetChannelReady(); SetChannelReady();
rtc::CopyOnWriteBuffer buffer(1024); rtc::CopyOnWriteBuffer buffer(1024);
memset(buffer.data(), 0, buffer.size()); memset(buffer.MutableData(), 0, buffer.size());
webrtc::DataBuffer packet(buffer, true); webrtc::DataBuffer packet(buffer, true);
// Send a packet while sending is blocked so it ends up buffered. // Send a packet while sending is blocked so it ends up buffered.

6
pc/sctp_utils_unittest.cc
View File

@ -178,15 +178,15 @@ TEST_F(SctpUtilsTest, WriteParseAckMessage) {
TEST_F(SctpUtilsTest, TestIsOpenMessage) { TEST_F(SctpUtilsTest, TestIsOpenMessage) {
rtc::CopyOnWriteBuffer open(1); rtc::CopyOnWriteBuffer open(1);
open[0] = 0x03; open.MutableData()[0] = 0x03;
EXPECT_TRUE(webrtc::IsOpenMessage(open)); EXPECT_TRUE(webrtc::IsOpenMessage(open));
rtc::CopyOnWriteBuffer openAck(1); rtc::CopyOnWriteBuffer openAck(1);
openAck[0] = 0x02; openAck.MutableData()[0] = 0x02;
EXPECT_FALSE(webrtc::IsOpenMessage(openAck)); EXPECT_FALSE(webrtc::IsOpenMessage(openAck));
rtc::CopyOnWriteBuffer invalid(1); rtc::CopyOnWriteBuffer invalid(1);
invalid[0] = 0x01; invalid.MutableData()[0] = 0x01;
EXPECT_FALSE(webrtc::IsOpenMessage(invalid)); EXPECT_FALSE(webrtc::IsOpenMessage(invalid));
rtc::CopyOnWriteBuffer empty; rtc::CopyOnWriteBuffer empty;

8
pc/srtp_transport.cc
View File

@ -128,7 +128,7 @@ bool SrtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
rtc::PacketOptions updated_options = options; rtc::PacketOptions updated_options = options;
TRACE_EVENT0("webrtc", "SRTP Encode"); TRACE_EVENT0("webrtc", "SRTP Encode");
bool res; bool res;
uint8_t* data = packet->data(); uint8_t* data = packet->MutableData();
int len = rtc::checked_cast<int>(packet->size()); int len = rtc::checked_cast<int>(packet->size());
// If ENABLE_EXTERNAL_AUTH flag is on then packet authentication is not done // If ENABLE_EXTERNAL_AUTH flag is on then packet authentication is not done
// inside libsrtp for a RTP packet. A external HMAC module will be writing // inside libsrtp for a RTP packet. A external HMAC module will be writing
@ -185,7 +185,7 @@ bool SrtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
} }
TRACE_EVENT0("webrtc", "SRTP Encode"); TRACE_EVENT0("webrtc", "SRTP Encode");
uint8_t* data = packet->data(); uint8_t* data = packet->MutableData();
int len = rtc::checked_cast<int>(packet->size()); int len = rtc::checked_cast<int>(packet->size());
if (!ProtectRtcp(data, len, static_cast<int>(packet->capacity()), &len)) { if (!ProtectRtcp(data, len, static_cast<int>(packet->capacity()), &len)) {
int type = -1; int type = -1;
@ -208,7 +208,7 @@ void SrtpTransport::OnRtpPacketReceived(rtc::CopyOnWriteBuffer packet,
return; return;
} }
TRACE_EVENT0("webrtc", "SRTP Decode"); TRACE_EVENT0("webrtc", "SRTP Decode");
char* data = packet.data<char>(); char* data = packet.MutableData<char>();
int len = rtc::checked_cast<int>(packet.size()); int len = rtc::checked_cast<int>(packet.size());
if (!UnprotectRtp(data, len, &len)) { if (!UnprotectRtp(data, len, &len)) {
int seq_num = -1; int seq_num = -1;
@ -240,7 +240,7 @@ void SrtpTransport::OnRtcpPacketReceived(rtc::CopyOnWriteBuffer packet,
return; return;
} }
TRACE_EVENT0("webrtc", "SRTP Decode"); TRACE_EVENT0("webrtc", "SRTP Decode");
char* data = packet.data<char>(); char* data = packet.MutableData<char>();
int len = rtc::checked_cast<int>(packet.size()); int len = rtc::checked_cast<int>(packet.size());
if (!UnprotectRtcp(data, len, &len)) { if (!UnprotectRtcp(data, len, &len)) {
int type = -1; int type = -1;

4
test/network/network_emulation.h
View File

@ -593,12 +593,12 @@ class FakePacketRoute : public EmulatedNetworkReceiverInterface {
RTC_CHECK_GE(size, sizeof(int)); RTC_CHECK_GE(size, sizeof(int));
sent_.emplace(next_packet_id_, packet); sent_.emplace(next_packet_id_, packet);
rtc::CopyOnWriteBuffer buf(size); rtc::CopyOnWriteBuffer buf(size);
reinterpret_cast<int*>(buf.data())[0] = next_packet_id_++; reinterpret_cast<int*>(buf.MutableData())[0] = next_packet_id_++;
route_->from->SendPacket(send_addr_, recv_addr_, buf); route_->from->SendPacket(send_addr_, recv_addr_, buf);
} }
void OnPacketReceived(EmulatedIpPacket packet) override { void OnPacketReceived(EmulatedIpPacket packet) override {
int packet_id = reinterpret_cast<int*>(packet.data.data())[0]; int packet_id = reinterpret_cast<const int*>(packet.data.data())[0];
action_(std::move(sent_[packet_id]), packet.arrival_time); action_(std::move(sent_[packet_id]), packet.arrival_time);
sent_.erase(packet_id); sent_.erase(packet_id);
} }

2
test/network/traffic_route.cc
View File

@ -88,7 +88,7 @@ void TrafficRoute::SendPacket(size_t packet_size) {
void TrafficRoute::SendPacket(size_t packet_size, uint16_t dest_port) { void TrafficRoute::SendPacket(size_t packet_size, uint16_t dest_port) {
rtc::CopyOnWriteBuffer data(packet_size); rtc::CopyOnWriteBuffer data(packet_size);
std::fill_n(data.data<uint8_t>(), data.size(), 0); std::fill_n(data.MutableData(), data.size(), 0);
receiver_->OnPacketReceived(EmulatedIpPacket( receiver_->OnPacketReceived(EmulatedIpPacket(
/*from=*/rtc::SocketAddress(), /*from=*/rtc::SocketAddress(),
rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), dest_port), data, rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), dest_port), data,

4
test/peer_scenario/tests/unsignaled_stream_test.cc
View File

@ -114,8 +114,8 @@ TEST(UnsignaledStreamTest, ReplacesUnsignaledStreamOnCompletedSignaling) {
first_ssrc && first_ssrc &&
!got_unsignaled_packet) { !got_unsignaled_packet) {
rtc::CopyOnWriteBuffer updated_buffer = packet.data; rtc::CopyOnWriteBuffer updated_buffer = packet.data;
ByteWriter<uint32_t>::WriteBigEndian(&updated_buffer.data()[8], ByteWriter<uint32_t>::WriteBigEndian(
second_ssrc); updated_buffer.MutableData() + 8, second_ssrc);
EmulatedIpPacket updated_packet( EmulatedIpPacket updated_packet(
packet.from, packet.to, updated_buffer, packet.arrival_time); packet.from, packet.to, updated_buffer, packet.arrival_time);
send_node->OnPacketReceived(std::move(updated_packet)); send_node->OnPacketReceived(std::move(updated_packet));