From 08ae7cea30d2e571a95ab3ebfe7f551fffec0e14 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Niels=20M=C3=B6ller?= Date: Wed, 23 Sep 2020 15:58:12 +0200 Subject: [PATCH] Reland "Delete the non-const version of the EncodedImage::data() method." This is a reland of f2969fa868f4913583e79f74ceced5cc6b7d6b7d Original change's description: > Delete the non-const version of the EncodedImage::data() method. > > Bug: webrtc:9378 > Change-Id: I84ace3ca6a2eb4d0f7c3d4e62f815d77df581bfa > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/185122 > Reviewed-by: Artem Titov > Reviewed-by: Philip Eliasson > Reviewed-by: Ilya Nikolaevskiy > Commit-Queue: Niels Moller > Cr-Commit-Position: refs/heads/master@{#32197} Bug: webrtc:9378 Change-Id: I8521ac567749ea547f91cf7549eb48966baffa11 Tbr: ilnik@webrtc.org Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/185807 Reviewed-by: Ilya Nikolaevskiy Reviewed-by: Marina Ciocea Reviewed-by: Niels Moller Commit-Queue: Niels Moller Cr-Commit-Position: refs/heads/master@{#32209} --- api/video/encoded_image.h | 5 --- .../codecs/h264/h264_encoder_impl.cc | 6 ++-- .../codecs/test/videoprocessor.cc | 10 +++--- modules/video_coding/frame_buffer.cc | 4 ++- modules/video_coding/frame_object.cc | 5 +-- modules/video_coding/frame_object.h | 4 +++ .../utility/simulcast_test_fixture_impl.cc | 22 ++++--------- test/fake_encoder.cc | 31 ++++++++++-------- test/fake_encoder.h | 11 +++++-- test/fake_vp8_encoder.cc | 6 ++-- test/fake_vp8_encoder.h | 4 ++- .../default_encoded_image_data_injector.cc | 32 +++++++++++-------- ...gle_process_encoded_image_data_injector.cc | 30 +++++++++-------- ...ss_encoded_image_data_injector_unittest.cc | 4 +-- video/buffered_frame_decryptor.cc | 2 +- video/video_stream_encoder_unittest.cc | 4 ++- 16 files changed, 97 insertions(+), 83 deletions(-) diff --git a/api/video/encoded_image.h b/api/video/encoded_image.h index 529b88bfc5..2e60d7e6bf 100644 --- a/api/video/encoded_image.h +++ b/api/video/encoded_image.h @@ -147,11 +147,6 @@ class RTC_EXPORT EncodedImage { return encoded_data_; } - // TODO(nisse): Delete, provide only read-only access to the buffer. - uint8_t* data() { - return buffer_ ? buffer_ - : (encoded_data_ ? encoded_data_->data() : nullptr); - } const uint8_t* data() const { return buffer_ ? buffer_ : (encoded_data_ ? encoded_data_->data() : nullptr); diff --git a/modules/video_coding/codecs/h264/h264_encoder_impl.cc b/modules/video_coding/codecs/h264/h264_encoder_impl.cc index 83f1f517cc..b869abeb36 100644 --- a/modules/video_coding/codecs/h264/h264_encoder_impl.cc +++ b/modules/video_coding/codecs/h264/h264_encoder_impl.cc @@ -110,7 +110,8 @@ static void RtpFragmentize(EncodedImage* encoded_image, SFrameBSInfo* info) { } } // TODO(nisse): Use a cache or buffer pool to avoid allocation? - encoded_image->SetEncodedData(EncodedImageBuffer::Create(required_capacity)); + auto buffer = EncodedImageBuffer::Create(required_capacity); + encoded_image->SetEncodedData(buffer); // Iterate layers and NAL units, note each NAL unit as a fragment and copy // the data to |encoded_image->_buffer|. @@ -132,8 +133,7 @@ static void RtpFragmentize(EncodedImage* encoded_image, SFrameBSInfo* info) { layer_len += layerInfo.pNalLengthInByte[nal]; } // Copy the entire layer's data (including start codes). - memcpy(encoded_image->data() + encoded_image->size(), layerInfo.pBsBuf, - layer_len); + memcpy(buffer->data() + encoded_image->size(), layerInfo.pBsBuf, layer_len); encoded_image->set_size(encoded_image->size() + layer_len); } } diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc index 8fbbe4a04e..f495bdd6c7 100644 --- a/modules/video_coding/codecs/test/videoprocessor.cc +++ b/modules/video_coding/codecs/test/videoprocessor.cc @@ -571,16 +571,16 @@ const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe( } const size_t payload_size_bytes = base_image.size() + encoded_image.size(); - EncodedImage copied_image = encoded_image; - copied_image.SetEncodedData(EncodedImageBuffer::Create(payload_size_bytes)); + auto buffer = EncodedImageBuffer::Create(payload_size_bytes); if (base_image.size()) { RTC_CHECK(base_image.data()); - memcpy(copied_image.data(), base_image.data(), base_image.size()); + memcpy(buffer->data(), base_image.data(), base_image.size()); } - memcpy(copied_image.data() + base_image.size(), encoded_image.data(), + memcpy(buffer->data() + base_image.size(), encoded_image.data(), encoded_image.size()); - copied_image.set_size(payload_size_bytes); + EncodedImage copied_image = encoded_image; + copied_image.SetEncodedData(buffer); // Replace previous EncodedImage for this spatial layer. merged_encoded_frames_.at(spatial_idx) = std::move(copied_image); diff --git a/modules/video_coding/frame_buffer.cc b/modules/video_coding/frame_buffer.cc index d30170a042..09c2733a1f 100644 --- a/modules/video_coding/frame_buffer.cc +++ b/modules/video_coding/frame_buffer.cc @@ -134,7 +134,9 @@ VCMFrameBufferEnum VCMFrameBuffer::InsertPacket(const VCMPacket& packet, if (packet.sizeBytes > 0) CopyCodecSpecific(&packet.video_header); - int retVal = _sessionInfo.InsertPacket(packet, data(), frame_data); + int retVal = _sessionInfo.InsertPacket( + packet, encoded_image_buffer_ ? encoded_image_buffer_->data() : nullptr, + frame_data); if (retVal == -1) { return kSizeError; } else if (retVal == -2) { diff --git a/modules/video_coding/frame_object.cc b/modules/video_coding/frame_object.cc index bdb43f7992..d58aa10aec 100644 --- a/modules/video_coding/frame_object.cc +++ b/modules/video_coding/frame_object.cc @@ -38,7 +38,8 @@ RtpFrameObject::RtpFrameObject( const absl::optional& color_space, RtpPacketInfos packet_infos, rtc::scoped_refptr image_buffer) - : first_seq_num_(first_seq_num), + : image_buffer_(image_buffer), + first_seq_num_(first_seq_num), last_seq_num_(last_seq_num), last_packet_received_time_(last_packet_received_time), times_nacked_(times_nacked) { @@ -60,7 +61,7 @@ RtpFrameObject::RtpFrameObject( // as of the first packet's. SetPlayoutDelay(rtp_video_header_.playout_delay); - SetEncodedData(std::move(image_buffer)); + SetEncodedData(image_buffer_); _encodedWidth = rtp_video_header_.width; _encodedHeight = rtp_video_header_.height; diff --git a/modules/video_coding/frame_object.h b/modules/video_coding/frame_object.h index 831b444df4..d812b8fd2e 100644 --- a/modules/video_coding/frame_object.h +++ b/modules/video_coding/frame_object.h @@ -48,7 +48,11 @@ class RtpFrameObject : public EncodedFrame { bool delayed_by_retransmission() const override; const RTPVideoHeader& GetRtpVideoHeader() const; + uint8_t* mutable_data() { return image_buffer_->data(); } + private: + // Reference for mutable access. + rtc::scoped_refptr image_buffer_; RTPVideoHeader rtp_video_header_; VideoCodecType codec_type_; uint16_t first_seq_num_; diff --git a/modules/video_coding/utility/simulcast_test_fixture_impl.cc b/modules/video_coding/utility/simulcast_test_fixture_impl.cc index b60f688186..f7d81bfbac 100644 --- a/modules/video_coding/utility/simulcast_test_fixture_impl.cc +++ b/modules/video_coding/utility/simulcast_test_fixture_impl.cc @@ -81,20 +81,13 @@ class SimulcastTestFixtureImpl::TestEncodedImageCallback // Only store the base layer. if (encoded_image.SpatialIndex().value_or(0) == 0) { if (encoded_image._frameType == VideoFrameType::kVideoFrameKey) { - // TODO(nisse): Why not size() ? - encoded_key_frame_.SetEncodedData( - EncodedImageBuffer::Create(encoded_image.size())); - encoded_key_frame_.set_size(encoded_image.size()); + encoded_key_frame_.SetEncodedData(EncodedImageBuffer::Create( + encoded_image.data(), encoded_image.size())); encoded_key_frame_._frameType = VideoFrameType::kVideoFrameKey; encoded_key_frame_._completeFrame = encoded_image._completeFrame; - memcpy(encoded_key_frame_.data(), encoded_image.data(), - encoded_image.size()); } else { - encoded_frame_.SetEncodedData( - EncodedImageBuffer::Create(encoded_image.size())); - encoded_frame_.set_size(encoded_image.size()); - memcpy(encoded_frame_.data(), encoded_image.data(), - encoded_image.size()); + encoded_frame_.SetEncodedData(EncodedImageBuffer::Create( + encoded_image.data(), encoded_image.size())); } } if (is_vp8) { @@ -873,13 +866,10 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() { EXPECT_EQ(encoded_image._frameType, VideoFrameType::kVideoFrameKey); size_t index = encoded_image.SpatialIndex().value_or(0); - encoded_frame[index].SetEncodedData( - EncodedImageBuffer::Create(encoded_image.size())); - encoded_frame[index].set_size(encoded_image.size()); + encoded_frame[index].SetEncodedData(EncodedImageBuffer::Create( + encoded_image.data(), encoded_image.size())); encoded_frame[index]._frameType = encoded_image._frameType; encoded_frame[index]._completeFrame = encoded_image._completeFrame; - memcpy(encoded_frame[index].data(), encoded_image.data(), - encoded_image.size()); return EncodedImageCallback::Result( EncodedImageCallback::Result::OK, 0); })); diff --git a/test/fake_encoder.cc b/test/fake_encoder.cc index a81791ee21..8fd2f6d0a6 100644 --- a/test/fake_encoder.cc +++ b/test/fake_encoder.cc @@ -128,14 +128,15 @@ int32_t FakeEncoder::Encode(const VideoFrame& input_image, continue; } - EncodedImage encoded; - encoded.SetEncodedData( - EncodedImageBuffer::Create(frame_info.layers[i].size)); - + auto buffer = EncodedImageBuffer::Create(frame_info.layers[i].size); // Fill the buffer with arbitrary data. Write someting to make Asan happy. - memset(encoded.data(), 9, frame_info.layers[i].size); + memset(buffer->data(), 9, frame_info.layers[i].size); // Write a counter to the image to make each frame unique. - WriteCounter(encoded.data() + frame_info.layers[i].size - 4, counter); + WriteCounter(buffer->data() + frame_info.layers[i].size - 4, counter); + + EncodedImage encoded; + encoded.SetEncodedData(buffer); + encoded.SetTimestamp(input_image.timestamp()); encoded._frameType = frame_info.keyframe ? VideoFrameType::kVideoFrameKey : VideoFrameType::kVideoFrameDelta; @@ -144,7 +145,7 @@ int32_t FakeEncoder::Encode(const VideoFrame& input_image, if (qp) encoded.qp_ = *qp; encoded.SetSpatialIndex(i); - CodecSpecificInfo codec_specific = EncodeHook(encoded); + CodecSpecificInfo codec_specific = EncodeHook(encoded, buffer); if (callback->OnEncodedImage(encoded, &codec_specific).error != EncodedImageCallback::Result::OK) { @@ -154,7 +155,9 @@ int32_t FakeEncoder::Encode(const VideoFrame& input_image, return 0; } -CodecSpecificInfo FakeEncoder::EncodeHook(EncodedImage& encoded_image) { +CodecSpecificInfo FakeEncoder::EncodeHook( + EncodedImage& encoded_image, + rtc::scoped_refptr buffer) { CodecSpecificInfo codec_specific; codec_specific.codecType = kVideoCodecGeneric; return codec_specific; @@ -284,7 +287,9 @@ int FakeEncoder::GetConfiguredInputFramerate() const { FakeH264Encoder::FakeH264Encoder(Clock* clock) : FakeEncoder(clock), idr_counter_(0) {} -CodecSpecificInfo FakeH264Encoder::EncodeHook(EncodedImage& encoded_image) { +CodecSpecificInfo FakeH264Encoder::EncodeHook( + EncodedImage& encoded_image, + rtc::scoped_refptr buffer) { static constexpr std::array kStartCode = {0, 0, 1}; const size_t kSpsSize = 8; const size_t kPpsSize = 11; @@ -296,7 +301,7 @@ CodecSpecificInfo FakeH264Encoder::EncodeHook(EncodedImage& encoded_image) { ++idr_counter_; } for (size_t i = 0; i < encoded_image.size(); ++i) { - encoded_image.data()[i] = static_cast(i); + buffer->data()[i] = static_cast(i); } if (current_idr_counter % kIdrFrequency == 0 && @@ -304,7 +309,7 @@ CodecSpecificInfo FakeH264Encoder::EncodeHook(EncodedImage& encoded_image) { const size_t kSpsNalHeader = 0x67; const size_t kPpsNalHeader = 0x68; const size_t kIdrNalHeader = 0x65; - uint8_t* data = encoded_image.data(); + uint8_t* data = buffer->data(); memcpy(data, kStartCode.data(), kStartCode.size()); data += kStartCode.size(); data[0] = kSpsNalHeader; @@ -319,9 +324,9 @@ CodecSpecificInfo FakeH264Encoder::EncodeHook(EncodedImage& encoded_image) { data += kStartCode.size(); data[0] = kIdrNalHeader; } else { - memcpy(encoded_image.data(), kStartCode.data(), kStartCode.size()); + memcpy(buffer->data(), kStartCode.data(), kStartCode.size()); const size_t kNalHeader = 0x41; - encoded_image.data()[kStartCode.size()] = kNalHeader; + buffer->data()[kStartCode.size()] = kNalHeader; } CodecSpecificInfo codec_specific; diff --git a/test/fake_encoder.h b/test/fake_encoder.h index d142258fdf..abd3134154 100644 --- a/test/fake_encoder.h +++ b/test/fake_encoder.h @@ -83,8 +83,11 @@ class FakeEncoder : public VideoEncoder { int framerate) RTC_LOCKS_EXCLUDED(mutex_); // Called before the frame is passed to callback_->OnEncodedImage, to let - // subclasses fill out CodecSpecificInfo, possibly modify |encoded_image|. - virtual CodecSpecificInfo EncodeHook(EncodedImage& encoded_image); + // subclasses fill out CodecSpecificInfo, possibly modify |encoded_image| or + // |buffer|. + virtual CodecSpecificInfo EncodeHook( + EncodedImage& encoded_image, + rtc::scoped_refptr buffer); void SetRatesLocked(const RateControlParameters& parameters) RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_); @@ -113,7 +116,9 @@ class FakeH264Encoder : public FakeEncoder { virtual ~FakeH264Encoder() = default; private: - CodecSpecificInfo EncodeHook(EncodedImage& encoded_image) override; + CodecSpecificInfo EncodeHook( + EncodedImage& encoded_image, + rtc::scoped_refptr buffer) override; int idr_counter_ RTC_GUARDED_BY(local_mutex_); Mutex local_mutex_; diff --git a/test/fake_vp8_encoder.cc b/test/fake_vp8_encoder.cc index 750806566c..abeedfc6b6 100644 --- a/test/fake_vp8_encoder.cc +++ b/test/fake_vp8_encoder.cc @@ -90,7 +90,9 @@ CodecSpecificInfo FakeVp8Encoder::PopulateCodecSpecific( return codec_specific; } -CodecSpecificInfo FakeVp8Encoder::EncodeHook(EncodedImage& encoded_image) { +CodecSpecificInfo FakeVp8Encoder::EncodeHook( + EncodedImage& encoded_image, + rtc::scoped_refptr buffer) { RTC_DCHECK_RUN_ON(&sequence_checker_); uint8_t stream_idx = encoded_image.SpatialIndex().value_or(0); frame_buffer_controller_->NextFrameConfig(stream_idx, @@ -101,7 +103,7 @@ CodecSpecificInfo FakeVp8Encoder::EncodeHook(EncodedImage& encoded_image) { // Write width and height to the payload the same way as the real encoder // does. - WriteFakeVp8(encoded_image.data(), encoded_image._encodedWidth, + WriteFakeVp8(buffer->data(), encoded_image._encodedWidth, encoded_image._encodedHeight, encoded_image._frameType == VideoFrameType::kVideoFrameKey); return codec_specific; diff --git a/test/fake_vp8_encoder.h b/test/fake_vp8_encoder.h index 9619deb00a..178a46070d 100644 --- a/test/fake_vp8_encoder.h +++ b/test/fake_vp8_encoder.h @@ -49,7 +49,9 @@ class FakeVp8Encoder : public FakeEncoder { int stream_idx, uint32_t timestamp); - CodecSpecificInfo EncodeHook(EncodedImage& encoded_image) override; + CodecSpecificInfo EncodeHook( + EncodedImage& encoded_image, + rtc::scoped_refptr buffer) override; SequenceChecker sequence_checker_; diff --git a/test/pc/e2e/analyzer/video/default_encoded_image_data_injector.cc b/test/pc/e2e/analyzer/video/default_encoded_image_data_injector.cc index 2634e6eea4..c5eab0a1b0 100644 --- a/test/pc/e2e/analyzer/video/default_encoded_image_data_injector.cc +++ b/test/pc/e2e/analyzer/video/default_encoded_image_data_injector.cc @@ -41,30 +41,34 @@ EncodedImage DefaultEncodedImageDataInjector::InjectData( bool discard, const EncodedImage& source, int /*coding_entity_id*/) { - EncodedImage out = source; - out.SetEncodedData( - EncodedImageBuffer::Create(source.size() + kEncodedImageBufferExpansion)); - memcpy(out.data(), source.data(), source.size()); + auto buffer = + EncodedImageBuffer::Create(source.size() + kEncodedImageBufferExpansion); + memcpy(buffer->data(), source.data(), source.size()); + size_t insertion_pos = source.size(); - out.data()[insertion_pos] = id & 0x00ff; - out.data()[insertion_pos + 1] = (id & 0xff00) >> 8; - out.data()[insertion_pos + 2] = source.size() & 0x000000ff; - out.data()[insertion_pos + 3] = (source.size() & 0x0000ff00) >> 8; - out.data()[insertion_pos + 4] = (source.size() & 0x00ff0000) >> 16; - out.data()[insertion_pos + 5] = (source.size() & 0xff000000) >> 24; + buffer->data()[insertion_pos] = id & 0x00ff; + buffer->data()[insertion_pos + 1] = (id & 0xff00) >> 8; + buffer->data()[insertion_pos + 2] = source.size() & 0x000000ff; + buffer->data()[insertion_pos + 3] = (source.size() & 0x0000ff00) >> 8; + buffer->data()[insertion_pos + 4] = (source.size() & 0x00ff0000) >> 16; + buffer->data()[insertion_pos + 5] = (source.size() & 0xff000000) >> 24; // We will store discard flag in the high bit of high byte of the size. RTC_CHECK_LT(source.size(), 1U << 31) << "High bit is already in use"; - out.data()[insertion_pos + 5] = - out.data()[insertion_pos + 5] | ((discard ? 1 : 0) << 7); + buffer->data()[insertion_pos + 5] = + buffer->data()[insertion_pos + 5] | ((discard ? 1 : 0) << 7); + + EncodedImage out = source; + out.SetEncodedData(buffer); return out; } EncodedImageExtractionResult DefaultEncodedImageDataInjector::ExtractData( const EncodedImage& source, int /*coding_entity_id*/) { + auto buffer = EncodedImageBuffer::Create(source.size()); EncodedImage out = source; - out.SetEncodedData(EncodedImageBuffer::Create(source.size())); + out.SetEncodedData(buffer); size_t source_pos = source.size() - 1; absl::optional id = absl::nullopt; @@ -115,7 +119,7 @@ EncodedImageExtractionResult DefaultEncodedImageDataInjector::ExtractData( if (!info.discard) { // Copy next encoded image payload from concatenated buffer only if it is // not discarded. - memcpy(&out.data()[out_pos], &source.data()[source_pos], info.length); + memcpy(&buffer->data()[out_pos], &source.data()[source_pos], info.length); out_pos += info.length; } source_pos += info.length + kEncodedImageBufferExpansion; diff --git a/test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector.cc b/test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector.cc index 419a7be07f..304cb67d37 100644 --- a/test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector.cc +++ b/test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector.cc @@ -45,22 +45,23 @@ EncodedImage SingleProcessEncodedImageDataInjector::InjectData( ev.infos[info.sub_id] = info; } + auto buffer = EncodedImageBuffer::Create(source.data(), source.size()); + buffer->data()[insertion_pos] = id & 0x00ff; + buffer->data()[insertion_pos + 1] = (id & 0xff00) >> 8; + buffer->data()[insertion_pos + 2] = info.sub_id; + EncodedImage out = source; - out.data()[insertion_pos] = id & 0x00ff; - out.data()[insertion_pos + 1] = (id & 0xff00) >> 8; - out.data()[insertion_pos + 2] = info.sub_id; + out.SetEncodedData(buffer); return out; } EncodedImageExtractionResult SingleProcessEncodedImageDataInjector::ExtractData( const EncodedImage& source, int coding_entity_id) { + size_t size = source.size(); + auto buffer = EncodedImageBuffer::Create(source.data(), source.size()); EncodedImage out = source; - - // Both |source| and |out| image will share the same buffer for payload or - // out will have a copy for it, so we can operate on the |out| buffer only. - uint8_t* buffer = out.data(); - size_t size = out.size(); + out.SetEncodedData(buffer); std::vector frame_sizes; std::vector frame_sl_index; @@ -84,9 +85,10 @@ EncodedImageExtractionResult SingleProcessEncodedImageDataInjector::ExtractData( size_t insertion_pos = prev_frames_size + frame_size - ExtractionInfo::kUsedBufferSize; // Extract frame id from first 2 bytes starting from insertion pos. - uint16_t next_id = buffer[insertion_pos] + (buffer[insertion_pos + 1] << 8); + uint16_t next_id = buffer->data()[insertion_pos] + + (buffer->data()[insertion_pos + 1] << 8); // Extract frame sub id from second 3 byte starting from insertion pos. - uint8_t sub_id = buffer[insertion_pos + 2]; + uint8_t sub_id = buffer->data()[insertion_pos + 2]; RTC_CHECK(!id || *id == next_id) << "Different frames encoded into single encoded image: " << *id << " vs " << next_id; @@ -135,15 +137,17 @@ EncodedImageExtractionResult SingleProcessEncodedImageDataInjector::ExtractData( if (info.discard) { // If this encoded image is marked to be discarded - erase it's payload // from the buffer. - memmove(&buffer[pos], &buffer[pos + frame_size], size - pos - frame_size); + memmove(&buffer->data()[pos], &buffer->data()[pos + frame_size], + size - pos - frame_size); RTC_CHECK_LT(frame_index, frame_sl_index.size()) << "codec doesn't support discard option or the image, that was " "supposed to be discarded, is lost"; out.SetSpatialLayerFrameSize(frame_sl_index[frame_index], 0); size -= frame_size; } else { - memcpy(&buffer[pos + frame_size - ExtractionInfo::kUsedBufferSize], - info.origin_data, ExtractionInfo::kUsedBufferSize); + memcpy( + &buffer->data()[pos + frame_size - ExtractionInfo::kUsedBufferSize], + info.origin_data, ExtractionInfo::kUsedBufferSize); pos += frame_size; } } diff --git a/test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector_unittest.cc b/test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector_unittest.cc index e191872bdf..da2391467d 100644 --- a/test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector_unittest.cc +++ b/test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector_unittest.cc @@ -238,7 +238,6 @@ TEST(SingleProcessEncodedImageDataInjector, EncodedImage concatenated; concatenated.SetEncodedData(EncodedImageBuffer::Create( concatenated_buffer.data(), concatenated_length)); - memcpy(concatenated.data(), concatenated_buffer.data(), concatenated_length); concatenated.SetSpatialIndex(2); concatenated.SetSpatialLayerFrameSize(0, intermediate1.size()); concatenated.SetSpatialLayerFrameSize(1, intermediate2.size()); @@ -293,8 +292,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectOnceExtractTwice) { #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) EncodedImage DeepCopyEncodedImage(const EncodedImage& source) { EncodedImage copy = source; - copy.SetEncodedData(EncodedImageBuffer::Create(source.size())); - memcpy(copy.data(), source.data(), source.size()); + copy.SetEncodedData(EncodedImageBuffer::Create(source.data(), source.size())); return copy; } diff --git a/video/buffered_frame_decryptor.cc b/video/buffered_frame_decryptor.cc index fc9dff5b02..187bac6ee4 100644 --- a/video/buffered_frame_decryptor.cc +++ b/video/buffered_frame_decryptor.cc @@ -73,7 +73,7 @@ BufferedFrameDecryptor::FrameDecision BufferedFrameDecryptor::DecryptFrame( frame->size()); RTC_CHECK_LE(max_plaintext_byte_size, frame->size()); // Place the decrypted frame inline into the existing frame. - rtc::ArrayView inline_decrypted_bitstream(frame->data(), + rtc::ArrayView inline_decrypted_bitstream(frame->mutable_data(), max_plaintext_byte_size); // Enable authenticating the header if the field trial isn't disabled. diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc index 504b7b7b9c..6909475efc 100644 --- a/video/video_stream_encoder_unittest.cc +++ b/video/video_stream_encoder_unittest.cc @@ -996,7 +996,9 @@ class VideoStreamEncoderTest : public ::testing::Test { return result; } - CodecSpecificInfo EncodeHook(EncodedImage& encoded_image) override { + CodecSpecificInfo EncodeHook( + EncodedImage& encoded_image, + rtc::scoped_refptr buffer) override { CodecSpecificInfo codec_specific; { MutexLock lock(&mutex_);