Rename EncodedImage::_length --> size_, and make private.
Use size() accessor function. Also replace most nearby uses of _buffer
with data().
Bug: webrtc:9378
Change-Id: I1ac3459612f7c6151bd057d05448da1c4e1c6e3d
Reviewed-on: https://webrtc-review.googlesource.com/c/116783
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26273}diff --git a/api/media_transport_interface.cc b/api/media_transport_interface.cc
index 2164198..ccdcb91 100644
--- a/api/media_transport_interface.cc
+++ b/api/media_transport_interface.cc
@@ -129,11 +129,10 @@
}
void MediaTransportEncodedVideoFrame::Retain() {
- if (encoded_image_._buffer && encoded_data_.empty()) {
- encoded_data_ =
- std::vector<uint8_t>(encoded_image_._buffer,
- encoded_image_._buffer + encoded_image_._length);
- encoded_image_._buffer = encoded_data_.data();
+ if (encoded_image_.data() && encoded_data_.empty()) {
+ encoded_data_ = std::vector<uint8_t>(
+ encoded_image_.data(), encoded_image_.data() + encoded_image_.size());
+ encoded_image_.set_buffer(encoded_data_.data(), encoded_image_.size());
}
}
diff --git a/api/test/loopback_media_transport_unittest.cc b/api/test/loopback_media_transport_unittest.cc
index c67a9d5..1337355 100644
--- a/api/test/loopback_media_transport_unittest.cc
+++ b/api/test/loopback_media_transport_unittest.cc
@@ -105,8 +105,8 @@
testing::StrictMock<MockMediaTransportVideoSinkInterface> sink;
uint8_t encoded_data[] = {1, 2, 3};
EncodedImage encoded_image;
- encoded_image._buffer = encoded_data;
- encoded_image._length = sizeof(encoded_data);
+ encoded_image.set_buffer(encoded_data, sizeof(encoded_data));
+ encoded_image.set_size(sizeof(encoded_data));
EXPECT_CALL(sink, OnData(1, testing::Property(
&MediaTransportEncodedVideoFrame::frame_id,
@@ -114,12 +114,12 @@
.WillOnce(testing::Invoke(
[&encoded_image](int frame_id,
const MediaTransportEncodedVideoFrame& frame) {
- EXPECT_NE(frame.encoded_image()._buffer, encoded_image._buffer);
- EXPECT_EQ(frame.encoded_image()._length, encoded_image._length);
- EXPECT_EQ(
- 0, memcmp(frame.encoded_image()._buffer, encoded_image._buffer,
- std::min(frame.encoded_image()._length,
- encoded_image._length)));
+ EXPECT_NE(frame.encoded_image().data(), encoded_image.data());
+ EXPECT_EQ(frame.encoded_image().size(), encoded_image.size());
+ EXPECT_EQ(0,
+ memcmp(frame.encoded_image().data(), encoded_image.data(),
+ std::min(frame.encoded_image().size(),
+ encoded_image.size())));
}));
transport_pair.second()->SetReceiveVideoSink(&sink);
diff --git a/api/video/encoded_image.cc b/api/video/encoded_image.cc
index 34d4813..994bf15 100644
--- a/api/video/encoded_image.cc
+++ b/api/video/encoded_image.cc
@@ -31,8 +31,8 @@
EncodedImage::EncodedImage(const EncodedImage&) = default;
-EncodedImage::EncodedImage(uint8_t* buffer, size_t length, size_t capacity)
- : _buffer(buffer), _length(length), capacity_(capacity) {}
+EncodedImage::EncodedImage(uint8_t* buffer, size_t size, size_t capacity)
+ : _buffer(buffer), size_(size), capacity_(capacity) {}
void EncodedImage::SetEncodeTime(int64_t encode_start_ms,
int64_t encode_finish_ms) {
diff --git a/api/video/encoded_image.h b/api/video/encoded_image.h
index ed1bb4b..4828b02 100644
--- a/api/video/encoded_image.h
+++ b/api/video/encoded_image.h
@@ -67,10 +67,10 @@
color_space ? absl::make_optional(*color_space) : absl::nullopt;
}
- size_t size() const { return _length; }
+ size_t size() const { return size_; }
void set_size(size_t new_size) {
RTC_DCHECK_LE(new_size, capacity_);
- _length = new_size;
+ size_ = new_size;
}
size_t capacity() const { return capacity_; }
@@ -89,8 +89,6 @@
int64_t capture_time_ms_ = 0;
FrameType _frameType = kVideoFrameDelta;
uint8_t* _buffer;
- // TODO(bugs.webrtc.org/9378): Rename to size_, capacity_ and make private.
- size_t _length;
VideoRotation rotation_ = kVideoRotation_0;
VideoContentType content_type_ = VideoContentType::UNSPECIFIED;
bool _completeFrame = false;
@@ -114,6 +112,7 @@
} timing_;
private:
+ size_t size_; // Size of encoded frame data.
size_t capacity_; // Allocated size of _buffer.
uint32_t timestamp_rtp_ = 0;
absl::optional<int> spatial_index_;
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 9958d36..6d13821 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -349,7 +349,7 @@
const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation) {
- fec_controller_->UpdateWithEncodedData(encoded_image._length,
+ fec_controller_->UpdateWithEncodedData(encoded_image.size(),
encoded_image._frameType);
rtc::CritScope lock(&crit_);
RTC_DCHECK(!rtp_modules_.empty());
@@ -377,7 +377,7 @@
bool send_result = rtp_modules_[stream_index]->SendOutgoingData(
encoded_image._frameType, rtp_config_.payload_type,
encoded_image.Timestamp(), encoded_image.capture_time_ms_,
- encoded_image._buffer, encoded_image._length, fragmentation,
+ encoded_image.data(), encoded_image.size(), fragmentation,
&rtp_video_header, &frame_id);
if (!send_result)
return Result(Result::ERROR_SEND_FAILED);
diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index f5731e9..73194eb 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -144,8 +144,8 @@
encoded_image.SetTimestamp(1);
encoded_image.capture_time_ms_ = 2;
encoded_image._frameType = kVideoFrameKey;
- encoded_image._buffer = &payload;
- encoded_image._length = 1;
+ encoded_image.set_buffer(&payload, 1);
+ encoded_image.set_size(1);
RtpVideoSenderTestFixture test({kSsrc1}, kPayloadType, {});
EXPECT_NE(
@@ -174,8 +174,8 @@
encoded_image_1.SetTimestamp(1);
encoded_image_1.capture_time_ms_ = 2;
encoded_image_1._frameType = kVideoFrameKey;
- encoded_image_1._buffer = &payload;
- encoded_image_1._length = 1;
+ encoded_image_1.set_buffer(&payload, 1);
+ encoded_image_1.set_size(1);
RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
@@ -218,8 +218,9 @@
encoded_image_1.SetTimestamp(1);
encoded_image_1.capture_time_ms_ = 2;
encoded_image_1._frameType = kVideoFrameKey;
- encoded_image_1._buffer = &payload;
- encoded_image_1._length = 1;
+ encoded_image_1.set_buffer(&payload, 1);
+ encoded_image_1.set_size(1);
+
EncodedImage encoded_image_2(encoded_image_1);
encoded_image_2.SetSpatialIndex(1);
diff --git a/modules/video_coding/codecs/h264/h264_decoder_impl.cc b/modules/video_coding/codecs/h264/h264_decoder_impl.cc
index 89155f2..298485a 100644
--- a/modules/video_coding/codecs/h264/h264_decoder_impl.cc
+++ b/modules/video_coding/codecs/h264/h264_decoder_impl.cc
@@ -241,7 +241,7 @@
ReportError();
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
}
- if (!input_image._buffer || !input_image._length) {
+ if (!input_image.data() || !input_image.size()) {
ReportError();
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
@@ -254,24 +254,23 @@
// FFmpeg requires padding due to some optimized bitstream readers reading 32
// or 64 bits at once and could read over the end. See avcodec_decode_video2.
RTC_CHECK_GE(input_image.capacity(),
- input_image._length +
+ input_image.size() +
EncodedImage::GetBufferPaddingBytes(kVideoCodecH264));
// "If the first 23 bits of the additional bytes are not 0, then damaged MPEG
// bitstreams could cause overread and segfault." See
// AV_INPUT_BUFFER_PADDING_SIZE. We'll zero the entire padding just in case.
- memset(input_image._buffer + input_image._length,
- 0,
+ memset(input_image._buffer + input_image.size(), 0,
EncodedImage::GetBufferPaddingBytes(kVideoCodecH264));
AVPacket packet;
av_init_packet(&packet);
packet.data = input_image._buffer;
- if (input_image._length >
+ if (input_image.size() >
static_cast<size_t>(std::numeric_limits<int>::max())) {
ReportError();
return WEBRTC_VIDEO_CODEC_ERROR;
}
- packet.size = static_cast<int>(input_image._length);
+ packet.size = static_cast<int>(input_image.size());
int64_t frame_timestamp_us = input_image.ntp_time_ms_ * 1000; // ms -> μs
av_context_->reordered_opaque = frame_timestamp_us;
@@ -318,8 +317,7 @@
absl::optional<uint8_t> qp;
// TODO(sakal): Maybe it is possible to get QP directly from FFmpeg.
- h264_bitstream_parser_.ParseBitstream(input_image._buffer,
- input_image._length);
+ h264_bitstream_parser_.ParseBitstream(input_image.data(), input_image.size());
int qp_int;
if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
qp.emplace(qp_int);
diff --git a/modules/video_coding/codecs/h264/h264_encoder_impl.cc b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
index 05b26fe..3eee819b 100644
--- a/modules/video_coding/codecs/h264/h264_encoder_impl.cc
+++ b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
@@ -135,7 +135,7 @@
const uint8_t start_code[4] = {0, 0, 0, 1};
frag_header->VerifyAndAllocateFragmentationHeader(fragments_count);
size_t frag = 0;
- encoded_image->_length = 0;
+ encoded_image->set_size(0);
for (int layer = 0; layer < info->iLayerNum; ++layer) {
const SLayerBSInfo& layerInfo = info->sLayerInfo[layer];
// Iterate NAL units making up this layer, noting fragments.
@@ -149,15 +149,15 @@
RTC_DCHECK_EQ(layerInfo.pBsBuf[layer_len + 2], start_code[2]);
RTC_DCHECK_EQ(layerInfo.pBsBuf[layer_len + 3], start_code[3]);
frag_header->fragmentationOffset[frag] =
- encoded_image->_length + layer_len + sizeof(start_code);
+ encoded_image->size() + layer_len + sizeof(start_code);
frag_header->fragmentationLength[frag] =
layerInfo.pNalLengthInByte[nal] - sizeof(start_code);
layer_len += layerInfo.pNalLengthInByte[nal];
}
// Copy the entire layer's data (including start codes).
- memcpy(encoded_image->_buffer + encoded_image->_length, layerInfo.pBsBuf,
+ memcpy(encoded_image->data() + encoded_image->size(), layerInfo.pBsBuf,
layer_len);
- encoded_image->_length += layer_len;
+ encoded_image->set_size(encoded_image->size() + layer_len);
}
}
@@ -308,7 +308,7 @@
encoded_images_[i]._completeFrame = true;
encoded_images_[i]._encodedWidth = codec_.simulcastStream[idx].width;
encoded_images_[i]._encodedHeight = codec_.simulcastStream[idx].height;
- encoded_images_[i]._length = 0;
+ encoded_images_[i].set_size(0);
}
SimulcastRateAllocator init_allocator(codec_);
@@ -519,10 +519,10 @@
// Encoder can skip frames to save bandwidth in which case
// |encoded_images_[i]._length| == 0.
- if (encoded_images_[i]._length > 0) {
+ if (encoded_images_[i].size() > 0) {
// Parse QP.
- h264_bitstream_parser_.ParseBitstream(encoded_images_[i]._buffer,
- encoded_images_[i]._length);
+ h264_bitstream_parser_.ParseBitstream(encoded_images_[i].data(),
+ encoded_images_[i].size());
h264_bitstream_parser_.GetLastSliceQp(&encoded_images_[i].qp_);
// Deliver encoded image.
diff --git a/modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc b/modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc
index 65146d7..03f3621 100644
--- a/modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc
+++ b/modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc
@@ -128,7 +128,7 @@
}
void PackBitstream(uint8_t* buffer, MultiplexImageComponent image) {
- memcpy(buffer, image.encoded_image._buffer, image.encoded_image._length);
+ memcpy(buffer, image.encoded_image.data(), image.encoded_image.size());
}
MultiplexImage::MultiplexImage(uint16_t picture_index,
@@ -170,7 +170,7 @@
const size_t padding =
EncodedImage::GetBufferPaddingBytes(images[i].codec_type);
frame_header.bitstream_length =
- static_cast<uint32_t>(images[i].encoded_image._length + padding);
+ static_cast<uint32_t>(images[i].encoded_image.size() + padding);
bitstream_offset += frame_header.bitstream_length;
frame_header.codec_type = images[i].codec_type;
@@ -188,9 +188,8 @@
frame_headers.push_back(frame_header);
}
- combined_image._length = bitstream_offset;
- combined_image.set_buffer(new uint8_t[combined_image._length],
- combined_image._length);
+ combined_image.set_buffer(new uint8_t[bitstream_offset], bitstream_offset);
+ combined_image.set_size(bitstream_offset);
// header
header_offset = PackHeader(combined_image._buffer, header);
@@ -268,7 +267,7 @@
static_cast<size_t>(frame_headers[i].bitstream_length));
const size_t padding =
EncodedImage::GetBufferPaddingBytes(image_component.codec_type);
- encoded_image._length = encoded_image.capacity() - padding;
+ encoded_image.set_size(encoded_image.capacity() - padding);
image_component.encoded_image = encoded_image;
diff --git a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
index 450cc4b..158efd3 100644
--- a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
+++ b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
@@ -275,9 +275,11 @@
image_component.codec_type =
PayloadStringToCodecType(associated_format_.name);
image_component.encoded_image = encodedImage;
- image_component.encoded_image._buffer = new uint8_t[encodedImage._length];
- std::memcpy(image_component.encoded_image._buffer, encodedImage._buffer,
- encodedImage._length);
+ image_component.encoded_image.set_buffer(new uint8_t[encodedImage.size()],
+ encodedImage.size());
+ image_component.encoded_image.set_size(encodedImage.size());
+ std::memcpy(image_component.encoded_image.data(), encodedImage.data(),
+ encodedImage.size());
rtc::CritScope cs(&crit_);
const auto& stashed_image_itr =
diff --git a/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc b/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
index de3dad3..88e11e9 100644
--- a/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
+++ b/modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
@@ -320,8 +320,7 @@
bool contains_pps = false;
bool contains_idr = false;
const std::vector<webrtc::H264::NaluIndex> nalu_indices =
- webrtc::H264::FindNaluIndices(encoded_frame._buffer,
- encoded_frame._length);
+ webrtc::H264::FindNaluIndices(encoded_frame.data(), encoded_frame.size());
for (const webrtc::H264::NaluIndex& index : nalu_indices) {
webrtc::H264::NaluType nalu_type = webrtc::H264::ParseNaluType(
encoded_frame._buffer[index.payload_start_offset]);
diff --git a/modules/video_coding/codecs/test/videocodec_test_libvpx.cc b/modules/video_coding/codecs/test/videocodec_test_libvpx.cc
index 4f63aa9..ae079c6 100644
--- a/modules/video_coding/codecs/test/videocodec_test_libvpx.cc
+++ b/modules/video_coding/codecs/test/videocodec_test_libvpx.cc
@@ -45,11 +45,9 @@
const EncodedImage& encoded_frame) const override {
int qp;
if (codec == kVideoCodecVP8) {
- EXPECT_TRUE(
- vp8::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+ EXPECT_TRUE(vp8::GetQp(encoded_frame.data(), encoded_frame.size(), &qp));
} else if (codec == kVideoCodecVP9) {
- EXPECT_TRUE(
- vp9::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+ EXPECT_TRUE(vp9::GetQp(encoded_frame.data(), encoded_frame.size(), &qp));
} else {
RTC_NOTREACHED();
}
diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc
index 85e7173..706df79 100644
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@@ -51,8 +51,7 @@
return 0;
std::vector<webrtc::H264::NaluIndex> nalu_indices =
- webrtc::H264::FindNaluIndices(encoded_frame._buffer,
- encoded_frame._length);
+ webrtc::H264::FindNaluIndices(encoded_frame.data(), encoded_frame.size());
RTC_CHECK(!nalu_indices.empty());
@@ -392,7 +391,7 @@
frame_stat->encode_start_ns, encode_stop_ns - post_encode_time_ns_);
frame_stat->target_bitrate_kbps =
bitrate_allocation_.GetTemporalLayerSum(spatial_idx, temporal_idx) / 1000;
- frame_stat->length_bytes = encoded_image._length;
+ frame_stat->length_bytes = encoded_image.size();
frame_stat->frame_type = encoded_image._frameType;
frame_stat->temporal_idx = temporal_idx;
frame_stat->max_nalu_size_bytes = GetMaxNaluSizeBytes(encoded_image, config_);
@@ -554,7 +553,7 @@
RTC_CHECK_GT(config_.NumberOfSpatialLayers(), 1);
EncodedImage base_image;
- RTC_CHECK_EQ(base_image._length, 0);
+ RTC_CHECK_EQ(base_image.size(), 0);
// Each SVC layer is decoded with dedicated decoder. Find the nearest
// non-dropped base frame and merge it and current frame into superframe.
@@ -568,29 +567,29 @@
}
}
}
- const size_t payload_size_bytes = base_image._length + encoded_image._length;
+ const size_t payload_size_bytes = base_image.size() + encoded_image.size();
const size_t buffer_size_bytes =
payload_size_bytes + EncodedImage::GetBufferPaddingBytes(codec);
uint8_t* copied_buffer = new uint8_t[buffer_size_bytes];
RTC_CHECK(copied_buffer);
- if (base_image._length) {
+ if (base_image.size()) {
RTC_CHECK(base_image._buffer);
- memcpy(copied_buffer, base_image._buffer, base_image._length);
+ memcpy(copied_buffer, base_image.data(), base_image.size());
}
- memcpy(copied_buffer + base_image._length, encoded_image._buffer,
- encoded_image._length);
+ memcpy(copied_buffer + base_image.size(), encoded_image.data(),
+ encoded_image.size());
EncodedImage copied_image = encoded_image;
copied_image = encoded_image;
copied_image.set_buffer(copied_buffer, buffer_size_bytes);
- copied_image._length = payload_size_bytes;
+ copied_image.set_size(payload_size_bytes);
// Replace previous EncodedImage for this spatial layer.
- uint8_t* old_buffer = merged_encoded_frames_.at(spatial_idx)._buffer;
- if (old_buffer) {
- delete[] old_buffer;
+ uint8_t* old_data = merged_encoded_frames_.at(spatial_idx).data();
+ if (old_data) {
+ delete[] old_data;
}
merged_encoded_frames_.at(spatial_idx) = copied_image;
diff --git a/modules/video_coding/codecs/test/videoprocessor.h b/modules/video_coding/codecs/test/videoprocessor.h
index aaf9ccf..943ca87 100644
--- a/modules/video_coding/codecs/test/videoprocessor.h
+++ b/modules/video_coding/codecs/test/videoprocessor.h
@@ -109,7 +109,7 @@
const webrtc::EncodedImage& encoded_image,
const webrtc::CodecSpecificInfo* codec_specific_info)
: video_processor_(video_processor),
- buffer_(encoded_image._buffer, encoded_image._length),
+ buffer_(encoded_image._buffer, encoded_image.size()),
encoded_image_(encoded_image),
codec_specific_info_(*codec_specific_info) {
encoded_image_._buffer = buffer_.data();
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc
index 7b95d2b..158f71b 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc
@@ -161,7 +161,7 @@
if (decode_complete_callback_ == NULL) {
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
}
- if (input_image._buffer == NULL && input_image._length > 0) {
+ if (input_image.data() == NULL && input_image.size() > 0) {
// Reset to avoid requesting key frames too often.
if (propagation_cnt_ > 0)
propagation_cnt_ = 0;
@@ -249,10 +249,10 @@
}
uint8_t* buffer = input_image._buffer;
- if (input_image._length == 0) {
+ if (input_image.size() == 0) {
buffer = NULL; // Triggers full frame concealment.
}
- if (vpx_codec_decode(decoder_, buffer, input_image._length, 0,
+ if (vpx_codec_decode(decoder_, buffer, input_image.size(), 0,
kDecodeDeadlineRealtime)) {
// Reset to avoid requesting key frames too often.
if (propagation_cnt_ > 0) {
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
index 9f2cb8e..57a362c 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
@@ -861,7 +861,7 @@
int qp = 0;
vpx_codec_control(&encoders_[encoder_idx], VP8E_GET_LAST_QUANTIZER_64, &qp);
temporal_layers_[stream_idx]->OnEncodeDone(
- timestamp, encoded_images_[encoder_idx]._length,
+ timestamp, encoded_images_[encoder_idx].size(),
(pkt.data.frame.flags & VPX_FRAME_IS_KEY) != 0, qp, vp8Info);
}
@@ -871,7 +871,7 @@
for (size_t encoder_idx = 0; encoder_idx < encoders_.size();
++encoder_idx, --stream_idx) {
vpx_codec_iter_t iter = NULL;
- encoded_images_[encoder_idx]._length = 0;
+ encoded_images_[encoder_idx].set_size(0);
encoded_images_[encoder_idx]._frameType = kVideoFrameDelta;
CodecSpecificInfo codec_specific;
const vpx_codec_cx_pkt_t* pkt = NULL;
@@ -879,7 +879,7 @@
NULL) {
switch (pkt->kind) {
case VPX_CODEC_CX_FRAME_PKT: {
- size_t length = encoded_images_[encoder_idx]._length;
+ size_t length = encoded_images_[encoder_idx].size();
if (pkt->data.frame.sz + length >
encoded_images_[encoder_idx].capacity()) {
uint8_t* buffer = new uint8_t[pkt->data.frame.sz + length];
@@ -890,8 +890,8 @@
}
memcpy(&encoded_images_[encoder_idx]._buffer[length],
pkt->data.frame.buf, pkt->data.frame.sz);
- encoded_images_[encoder_idx]._length += pkt->data.frame.sz;
- assert(length <= encoded_images_[encoder_idx].capacity());
+ encoded_images_[encoder_idx].set_size(
+ encoded_images_[encoder_idx].size() + pkt->data.frame.sz);
break;
}
default:
@@ -921,9 +921,9 @@
encoded_images_[encoder_idx].SetColorSpace(input_image.color_space());
if (send_stream_[stream_idx]) {
- if (encoded_images_[encoder_idx]._length > 0) {
+ if (encoded_images_[encoder_idx].size() > 0) {
TRACE_COUNTER_ID1("webrtc", "EncodedFrameSize", encoder_idx,
- encoded_images_[encoder_idx]._length);
+ encoded_images_[encoder_idx].size());
encoded_images_[encoder_idx]._encodedHeight =
codec_.simulcastStream[stream_idx].height;
encoded_images_[encoder_idx]._encodedWidth =
@@ -937,7 +937,7 @@
} else if (!temporal_layers_[stream_idx]
->SupportsEncoderFrameDropping()) {
result = WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT;
- if (encoded_images_[encoder_idx]._length == 0) {
+ if (encoded_images_[encoder_idx].size() == 0) {
// Dropped frame that will be re-encoded.
temporal_layers_[stream_idx]->OnEncodeDone(input_image.timestamp(), 0,
false, 0, nullptr);
diff --git a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
index ccc294c..12ffcb5 100644
--- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@@ -98,8 +98,8 @@
void VerifyQpParser(const EncodedImage& encoded_frame) const {
int qp;
- EXPECT_GT(encoded_frame._length, 0u);
- ASSERT_TRUE(vp8::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+ EXPECT_GT(encoded_frame.size(), 0u);
+ ASSERT_TRUE(vp8::GetQp(encoded_frame.data(), encoded_frame.size(), &qp));
EXPECT_EQ(encoded_frame.qp_, qp) << "Encoder QP != parsed bitstream QP.";
}
};
diff --git a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
index 085af97..98e0452 100644
--- a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
@@ -243,7 +243,7 @@
ASSERT_TRUE(WaitForEncodedFrame(&encoded_frame, &codec_specific_info));
int qp = 0;
- ASSERT_TRUE(vp9::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
+ ASSERT_TRUE(vp9::GetQp(encoded_frame.data(), encoded_frame.size(), &qp));
EXPECT_EQ(encoded_frame.qp_, qp);
}
diff --git a/modules/video_coding/codecs/vp9/vp9_impl.cc b/modules/video_coding/codecs/vp9/vp9_impl.cc
index 6f3e979..3b92738 100644
--- a/modules/video_coding/codecs/vp9/vp9_impl.cc
+++ b/modules/video_coding/codecs/vp9/vp9_impl.cc
@@ -1263,7 +1263,7 @@
pkt->data.frame.sz);
}
memcpy(encoded_image_._buffer, pkt->data.frame.buf, pkt->data.frame.sz);
- encoded_image_._length = pkt->data.frame.sz;
+ encoded_image_.set_size(pkt->data.frame.sz);
const bool is_key_frame =
(pkt->data.frame.flags & VPX_FRAME_IS_KEY) ? true : false;
@@ -1276,7 +1276,7 @@
encoded_image_._frameType = kVideoFrameKey;
force_key_frame_ = false;
}
- RTC_DCHECK_LE(encoded_image_._length, encoded_image_.capacity());
+ RTC_DCHECK_LE(encoded_image_.size(), encoded_image_.capacity());
memset(&codec_specific_, 0, sizeof(codec_specific_));
absl::optional<int> spatial_index;
@@ -1288,7 +1288,7 @@
UpdateReferenceBuffers(*pkt, pics_since_key_);
}
- TRACE_COUNTER1("webrtc", "EncodedFrameSize", encoded_image_._length);
+ TRACE_COUNTER1("webrtc", "EncodedFrameSize", encoded_image_.size());
encoded_image_.SetTimestamp(input_image_->timestamp());
encoded_image_.capture_time_ms_ = input_image_->render_time_ms();
encoded_image_.rotation_ = input_image_->rotation();
@@ -1315,7 +1315,7 @@
}
void VP9EncoderImpl::DeliverBufferedFrame(bool end_of_picture) {
- if (encoded_image_._length > 0) {
+ if (encoded_image_.size() > 0) {
codec_specific_.codecSpecific.VP9.end_of_picture = end_of_picture;
// No data partitioning in VP9, so 1 partition only.
@@ -1323,13 +1323,13 @@
RTPFragmentationHeader frag_info;
frag_info.VerifyAndAllocateFragmentationHeader(1);
frag_info.fragmentationOffset[part_idx] = 0;
- frag_info.fragmentationLength[part_idx] = encoded_image_._length;
+ frag_info.fragmentationLength[part_idx] = encoded_image_.size();
frag_info.fragmentationPlType[part_idx] = 0;
frag_info.fragmentationTimeDiff[part_idx] = 0;
encoded_complete_callback_->OnEncodedImage(encoded_image_, &codec_specific_,
&frag_info);
- encoded_image_._length = 0;
+ encoded_image_.set_size(0);
if (codec_.mode == VideoCodecMode::kScreensharing) {
const uint8_t spatial_idx = encoded_image_.SpatialIndex().value_or(0);
@@ -1432,13 +1432,13 @@
vpx_codec_iter_t iter = nullptr;
vpx_image_t* img;
uint8_t* buffer = input_image._buffer;
- if (input_image._length == 0) {
+ if (input_image.size() == 0) {
buffer = nullptr; // Triggers full frame concealment.
}
// During decode libvpx may get and release buffers from |frame_buffer_pool_|.
// In practice libvpx keeps a few (~3-4) buffers alive at a time.
if (vpx_codec_decode(decoder_, buffer,
- static_cast<unsigned int>(input_image._length), 0,
+ static_cast<unsigned int>(input_image.size()), 0,
VPX_DL_REALTIME)) {
return WEBRTC_VIDEO_CODEC_ERROR;
}
diff --git a/modules/video_coding/encoded_frame.cc b/modules/video_coding/encoded_frame.cc
index e19146d..3c677f7 100644
--- a/modules/video_coding/encoded_frame.cc
+++ b/modules/video_coding/encoded_frame.cc
@@ -52,7 +52,7 @@
_encodedHeight = 0;
_completeFrame = false;
_missingFrame = false;
- _length = 0;
+ set_size(0);
_codecSpecificInfo.codecType = kVideoCodecGeneric;
_codec = kVideoCodecGeneric;
rotation_ = kVideoRotation_0;
diff --git a/modules/video_coding/frame_buffer.cc b/modules/video_coding/frame_buffer.cc
index 9be2ef0..908a2a2 100644
--- a/modules/video_coding/frame_buffer.cc
+++ b/modules/video_coding/frame_buffer.cc
@@ -138,8 +138,8 @@
} else if (retVal == -3) {
return kOutOfBoundsPacket;
}
- // update length
- _length = size() + static_cast<uint32_t>(retVal);
+ // update size
+ set_size(size() + static_cast<uint32_t>(retVal));
_latestPacketTimeMs = timeInMs;
@@ -216,7 +216,7 @@
void VCMFrameBuffer::Reset() {
TRACE_EVENT0("webrtc", "VCMFrameBuffer::Reset");
- _length = 0;
+ set_size(0);
_sessionInfo.Reset();
_payloadType = 0;
_nackCount = 0;
@@ -265,7 +265,7 @@
void VCMFrameBuffer::PrepareForDecode(bool continuous) {
TRACE_EVENT0("webrtc", "VCMFrameBuffer::PrepareForDecode");
size_t bytes_removed = _sessionInfo.MakeDecodable();
- _length -= bytes_removed;
+ set_size(size() - bytes_removed);
// Transfer frame information to EncodedFrame and create any codec
// specific information.
_frameType = _sessionInfo.FrameType();
diff --git a/modules/video_coding/frame_buffer2_unittest.cc b/modules/video_coding/frame_buffer2_unittest.cc
index 321281f..94a5551 100644
--- a/modules/video_coding/frame_buffer2_unittest.cc
+++ b/modules/video_coding/frame_buffer2_unittest.cc
@@ -91,10 +91,6 @@
int64_t ReceivedTime() const override { return 0; }
int64_t RenderTime() const override { return _renderTimeMs; }
-
- // In EncodedImage |_length| is used to descibe its size and |_size| to
- // describe its capacity.
- void SetSize(int size) { _length = size; }
};
class VCMReceiveStatisticsCallbackMock : public VCMReceiveStatisticsCallback {
@@ -168,7 +164,7 @@
frame->is_last_spatial_layer = last_spatial_layer;
// Add some data to buffer.
frame->VerifyAndAllocate(kFrameSize);
- frame->SetSize(kFrameSize);
+ frame->set_size(kFrameSize);
for (size_t r = 0; r < references.size(); ++r)
frame->references[r] = references[r];
@@ -491,7 +487,7 @@
{
std::unique_ptr<FrameObjectFake> frame(new FrameObjectFake());
frame->VerifyAndAllocate(kFrameSize);
- frame->SetSize(kFrameSize);
+ frame->set_size(kFrameSize);
frame->id.picture_id = pid;
frame->id.spatial_layer = 0;
frame->SetTimestamp(ts);
diff --git a/modules/video_coding/frame_object.cc b/modules/video_coding/frame_object.cc
index 8fd8983..6fcb573 100644
--- a/modules/video_coding/frame_object.cc
+++ b/modules/video_coding/frame_object.cc
@@ -139,11 +139,6 @@
return _renderTimeMs;
}
-void RtpFrameObject::SetSize(size_t size) {
- RTC_DCHECK_LE(size, capacity());
- _length = size;
-}
-
bool RtpFrameObject::delayed_by_retransmission() const {
return times_nacked() > 0;
}
@@ -188,7 +183,7 @@
set_buffer(new uint8_t[new_size], new_size);
}
- _length = frame_size;
+ set_size(frame_size);
}
} // namespace video_coding
diff --git a/modules/video_coding/frame_object.h b/modules/video_coding/frame_object.h
index 5a3efd9..8b9ad92 100644
--- a/modules/video_coding/frame_object.h
+++ b/modules/video_coding/frame_object.h
@@ -40,7 +40,6 @@
VideoCodecType codec_type() const;
int64_t ReceivedTime() const override;
int64_t RenderTime() const override;
- void SetSize(size_t size);
bool delayed_by_retransmission() const override;
absl::optional<RTPVideoHeader> GetRtpVideoHeader() const;
absl::optional<RtpGenericFrameDescriptor> GetGenericFrameDescriptor() const;
diff --git a/modules/video_coding/generic_encoder.cc b/modules/video_coding/generic_encoder.cc
index 221a8b2..52a82f3 100644
--- a/modules/video_coding/generic_encoder.cc
+++ b/modules/video_coding/generic_encoder.cc
@@ -327,7 +327,7 @@
// Outliers trigger timing frames, but do not affect scheduled timing
// frames.
- if (outlier_frame_size && encoded_image->_length >= *outlier_frame_size) {
+ if (outlier_frame_size && encoded_image->size() >= *outlier_frame_size) {
timing_flags |= VideoSendTiming::kTriggeredBySize;
}
diff --git a/modules/video_coding/generic_encoder_unittest.cc b/modules/video_coding/generic_encoder_unittest.cc
index 66d7873..4ea2506 100644
--- a/modules/video_coding/generic_encoder_unittest.cc
+++ b/modules/video_coding/generic_encoder_unittest.cc
@@ -82,6 +82,7 @@
{delay_ms, kDefaultOutlierFrameSizePercent});
callback.OnFrameRateChanged(kFramerate);
int s, i;
+ std::vector<uint8_t> frame_data(max_frame_size);
std::vector<std::vector<FrameType>> result(num_streams);
for (s = 0; s < num_streams; ++s)
callback.OnTargetBitrateChanged(average_frame_sizes[s] * kFramerate, s);
@@ -94,7 +95,8 @@
EncodedImage image;
CodecSpecificInfo codec_specific;
- image._length = FrameSize(min_frame_size, max_frame_size, s, i);
+ image.set_buffer(frame_data.data(), frame_data.size());
+ image.set_size(FrameSize(min_frame_size, max_frame_size, s, i));
image.capture_time_ms_ = current_timestamp;
image.SetTimestamp(static_cast<uint32_t>(current_timestamp * 90));
image.SetSpatialIndex(s);
@@ -187,7 +189,9 @@
EncodedImage image;
CodecSpecificInfo codec_specific;
int64_t timestamp = 1;
- image._length = 500;
+ uint8_t frame_data[500];
+ image.set_buffer(frame_data, sizeof(frame_data));
+ image.set_size(sizeof(frame_data));
image.capture_time_ms_ = timestamp;
image.SetTimestamp(static_cast<uint32_t>(timestamp * 90));
codec_specific.codecType = kVideoCodecGeneric;
@@ -218,7 +222,9 @@
const int64_t kEncodeStartDelayMs = 2;
const int64_t kEncodeFinishDelayMs = 10;
int64_t timestamp = 1;
- image._length = 500;
+ uint8_t frame_data[500];
+ image.set_buffer(frame_data, sizeof(frame_data));
+ image.set_size(sizeof(frame_data));
image.capture_time_ms_ = timestamp;
image.SetTimestamp(static_cast<uint32_t>(timestamp * 90));
codec_specific.codecType = kVideoCodecGeneric;
diff --git a/modules/video_coding/utility/ivf_file_writer.cc b/modules/video_coding/utility/ivf_file_writer.cc
index d9917c8..225996a 100644
--- a/modules/video_coding/utility/ivf_file_writer.cc
+++ b/modules/video_coding/utility/ivf_file_writer.cc
@@ -160,7 +160,7 @@
const size_t kFrameHeaderSize = 12;
if (byte_limit_ != 0 &&
- bytes_written_ + kFrameHeaderSize + encoded_image._length > byte_limit_) {
+ bytes_written_ + kFrameHeaderSize + encoded_image.size() > byte_limit_) {
RTC_LOG(LS_WARNING) << "Closing IVF file due to reaching size limit: "
<< byte_limit_ << " bytes.";
Close();
@@ -168,16 +168,16 @@
}
uint8_t frame_header[kFrameHeaderSize] = {};
ByteWriter<uint32_t>::WriteLittleEndian(
- &frame_header[0], static_cast<uint32_t>(encoded_image._length));
+ &frame_header[0], static_cast<uint32_t>(encoded_image.size()));
ByteWriter<uint64_t>::WriteLittleEndian(&frame_header[4], timestamp);
if (file_.Write(frame_header, kFrameHeaderSize) < kFrameHeaderSize ||
- file_.Write(encoded_image._buffer, encoded_image._length) <
- encoded_image._length) {
+ file_.Write(encoded_image.data(), encoded_image.size()) <
+ encoded_image.size()) {
RTC_LOG(LS_ERROR) << "Unable to write frame to file.";
return false;
}
- bytes_written_ += kFrameHeaderSize + encoded_image._length;
+ bytes_written_ += kFrameHeaderSize + encoded_image.size();
++num_frames_;
return true;
diff --git a/modules/video_coding/utility/ivf_file_writer_unittest.cc b/modules/video_coding/utility/ivf_file_writer_unittest.cc
index 6f71496..82d604a 100644
--- a/modules/video_coding/utility/ivf_file_writer_unittest.cc
+++ b/modules/video_coding/utility/ivf_file_writer_unittest.cc
@@ -41,11 +41,11 @@
int num_frames,
bool use_capture_tims_ms) {
EncodedImage frame;
- frame._buffer = dummy_payload;
+ frame.set_buffer(dummy_payload, sizeof(dummy_payload));
frame._encodedWidth = width;
frame._encodedHeight = height;
for (int i = 1; i <= num_frames; ++i) {
- frame._length = i % sizeof(dummy_payload);
+ frame.set_size(i % sizeof(dummy_payload));
if (use_capture_tims_ms) {
frame.capture_time_ms_ = i;
} else {
diff --git a/modules/video_coding/utility/simulcast_test_fixture_impl.cc b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
index 0230316..6700e87 100644
--- a/modules/video_coding/utility/simulcast_test_fixture_impl.cc
+++ b/modules/video_coding/utility/simulcast_test_fixture_impl.cc
@@ -85,18 +85,18 @@
delete[] encoded_key_frame_._buffer;
encoded_key_frame_.set_buffer(new uint8_t[encoded_image.capacity()],
encoded_image.capacity());
- encoded_key_frame_._length = encoded_image._length;
+ encoded_key_frame_.set_size(encoded_image.size());
encoded_key_frame_._frameType = kVideoFrameKey;
encoded_key_frame_._completeFrame = encoded_image._completeFrame;
memcpy(encoded_key_frame_._buffer, encoded_image._buffer,
- encoded_image._length);
+ encoded_image.size());
} else {
delete[] encoded_frame_._buffer;
encoded_frame_.set_buffer(new uint8_t[encoded_image.capacity()],
encoded_image.capacity());
- encoded_frame_._length = encoded_image._length;
+ encoded_frame_.set_size(encoded_image.size());
memcpy(encoded_frame_._buffer, encoded_image._buffer,
- encoded_image._length);
+ encoded_image.size());
}
}
if (is_vp8) {
@@ -858,11 +858,11 @@
encoded_frame[index].set_buffer(
new uint8_t[encoded_image.capacity()],
encoded_image.capacity());
- encoded_frame[index]._length = encoded_image._length;
+ encoded_frame[index].set_size(encoded_image.size());
encoded_frame[index]._frameType = encoded_image._frameType;
encoded_frame[index]._completeFrame = encoded_image._completeFrame;
memcpy(encoded_frame[index]._buffer, encoded_image._buffer,
- encoded_image._length);
+ encoded_image.size());
return EncodedImageCallback::Result(
EncodedImageCallback::Result::OK, 0);
}));
diff --git a/modules/video_coding/video_packet_buffer_unittest.cc b/modules/video_coding/video_packet_buffer_unittest.cc
index 49b1c26..190e0e7 100644
--- a/modules/video_coding/video_packet_buffer_unittest.cc
+++ b/modules/video_coding/video_packet_buffer_unittest.cc
@@ -643,7 +643,7 @@
packet_buffer_->InsertPacket(&packet);
ASSERT_EQ(1UL, frames_from_callback_.size());
- EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage()._length,
+ EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().size(),
sizeof(data_data));
EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage().capacity(),
sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264);
diff --git a/modules/video_coding/video_sender_unittest.cc b/modules/video_coding/video_sender_unittest.cc
index 44e9c34..11a69be 100644
--- a/modules/video_coding/video_sender_unittest.cc
+++ b/modules/video_coding/video_sender_unittest.cc
@@ -104,7 +104,7 @@
const RTPFragmentationHeader* fragmentation) override {
assert(codec_specific_info);
frame_data_.push_back(
- FrameData(encoded_image._length, *codec_specific_info));
+ FrameData(encoded_image.size(), *codec_specific_info));
return Result(Result::OK, encoded_image.Timestamp());
}
diff --git a/sdk/android/src/jni/android_media_decoder.cc b/sdk/android/src/jni/android_media_decoder.cc
index a73167d..35f415e 100644
--- a/sdk/android/src/jni/android_media_decoder.cc
+++ b/sdk/android/src/jni/android_media_decoder.cc
@@ -360,7 +360,7 @@
ALOGE << "Decode() - callback_ is NULL";
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
}
- if (inputImage._buffer == NULL && inputImage._length > 0) {
+ if (inputImage.data() == NULL && inputImage.size() > 0) {
ALOGE << "Decode() - inputImage is incorrect";
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
@@ -408,7 +408,7 @@
}
key_frame_required_ = false;
}
- if (inputImage._length == 0) {
+ if (inputImage.size() == 0) {
return WEBRTC_VIDEO_CODEC_ERROR;
}
@@ -476,35 +476,34 @@
RTC_CHECK(buffer) << "Indirect buffer??";
size_t buffer_capacity =
rtc::dchecked_cast<size_t>(jni->GetDirectBufferCapacity(j_input_buffer));
- if (CheckException(jni) || buffer_capacity < inputImage._length) {
- ALOGE << "Input frame size " << inputImage._length
+ if (CheckException(jni) || buffer_capacity < inputImage.size()) {
+ ALOGE << "Input frame size " << inputImage.size()
<< " is bigger than buffer size " << buffer_capacity;
return ProcessHWErrorOnCodecThread();
}
jlong presentation_timestamp_us = static_cast<jlong>(
static_cast<int64_t>(frames_received_) * 1000000 / codec_.maxFramerate);
- memcpy(buffer, inputImage._buffer, inputImage._length);
+ memcpy(buffer, inputImage.data(), inputImage.size());
if (frames_decoded_ < frames_decoded_logged_) {
ALOGD << "Decoder frame in # " << frames_received_
<< ". Type: " << inputImage._frameType << ". Buffer # "
<< j_input_buffer_index
<< ". TS: " << presentation_timestamp_us / 1000
- << ". Size: " << inputImage._length;
+ << ". Size: " << inputImage.size();
}
// Save input image timestamps for later output.
frames_received_++;
- current_bytes_ += inputImage._length;
+ current_bytes_ += inputImage.size();
absl::optional<uint8_t> qp;
if (codecType_ == kVideoCodecVP8) {
int qp_int;
- if (vp8::GetQp(inputImage._buffer, inputImage._length, &qp_int)) {
+ if (vp8::GetQp(inputImage.data(), inputImage.size(), &qp_int)) {
qp = qp_int;
}
} else if (codecType_ == kVideoCodecH264) {
- h264_bitstream_parser_.ParseBitstream(inputImage._buffer,
- inputImage._length);
+ h264_bitstream_parser_.ParseBitstream(inputImage.data(), inputImage.size());
int qp_int;
if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
qp = qp_int;
@@ -515,7 +514,7 @@
// Feed input to decoder.
bool success = Java_MediaCodecVideoDecoder_queueInputBuffer(
jni, j_media_codec_video_decoder_, j_input_buffer_index,
- static_cast<int>(inputImage._length), presentation_timestamp_us,
+ static_cast<int>(inputImage.size()), presentation_timestamp_us,
static_cast<int64_t>(inputImage.Timestamp()), inputImage.ntp_time_ms_);
if (CheckException(jni) || !success) {
ALOGE << "queueInputBuffer error";
diff --git a/sdk/android/src/jni/android_media_encoder.cc b/sdk/android/src/jni/android_media_encoder.cc
index aaa2d9a..69f01346 100644
--- a/sdk/android/src/jni/android_media_encoder.cc
+++ b/sdk/android/src/jni/android_media_encoder.cc
@@ -1047,7 +1047,7 @@
if (codec_type == kVideoCodecVP8 || codec_type == kVideoCodecVP9) {
header.VerifyAndAllocateFragmentationHeader(1);
header.fragmentationOffset[0] = 0;
- header.fragmentationLength[0] = image->_length;
+ header.fragmentationLength[0] = image->size();
header.fragmentationPlType[0] = 0;
header.fragmentationTimeDiff[0] = 0;
if (codec_type == kVideoCodecVP8) {
diff --git a/sdk/android/src/jni/encoded_image.cc b/sdk/android/src/jni/encoded_image.cc
index daa7788..c801ce5f 100644
--- a/sdk/android/src/jni/encoded_image.cc
+++ b/sdk/android/src/jni/encoded_image.cc
@@ -27,8 +27,8 @@
ScopedJavaLocalRef<jobject> NativeToJavaEncodedImage(
JNIEnv* jni,
const EncodedImage& image) {
- ScopedJavaLocalRef<jobject> buffer =
- NewDirectByteBuffer(jni, image._buffer, image._length);
+ ScopedJavaLocalRef<jobject> buffer = NewDirectByteBuffer(
+ jni, const_cast<uint8_t*>(image.data()), image.size());
ScopedJavaLocalRef<jobject> frame_type =
NativeToJavaFrameType(jni, image._frameType);
ScopedJavaLocalRef<jobject> qp;
diff --git a/sdk/android/src/jni/video_decoder_wrapper.cc b/sdk/android/src/jni/video_decoder_wrapper.cc
index 26dc3d5..037aef1 100644
--- a/sdk/android/src/jni/video_decoder_wrapper.cc
+++ b/sdk/android/src/jni/video_decoder_wrapper.cc
@@ -237,21 +237,21 @@
switch (codec_settings_.codecType) {
case kVideoCodecVP8: {
int qp_int;
- if (vp8::GetQp(input_image._buffer, input_image._length, &qp_int)) {
+ if (vp8::GetQp(input_image.data(), input_image.size(), &qp_int)) {
qp = qp_int;
}
break;
}
case kVideoCodecVP9: {
int qp_int;
- if (vp9::GetQp(input_image._buffer, input_image._length, &qp_int)) {
+ if (vp9::GetQp(input_image.data(), input_image.size(), &qp_int)) {
qp = qp_int;
}
break;
}
case kVideoCodecH264: {
- h264_bitstream_parser_.ParseBitstream(input_image._buffer,
- input_image._length);
+ h264_bitstream_parser_.ParseBitstream(input_image.data(),
+ input_image.size());
int qp_int;
if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
qp = qp_int;
diff --git a/sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm b/sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm
index 6f2d1f4..59962c8 100644
--- a/sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm
+++ b/sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm
@@ -17,9 +17,9 @@
- (instancetype)initWithNativeEncodedImage:(webrtc::EncodedImage)encodedImage {
if (self = [super init]) {
// Wrap the buffer in NSData without copying, do not take ownership.
- self.buffer = [NSData dataWithBytesNoCopy:encodedImage._buffer
- length:encodedImage._length
- freeWhenDone:NO];
+ self.buffer = [NSData dataWithBytesNoCopy:encodedImage.data()
+ length:encodedImage.size()
+ freeWhenDone:NO];
self.encodedWidth = rtc::dchecked_cast<int32_t>(encodedImage._encodedWidth);
self.encodedHeight = rtc::dchecked_cast<int32_t>(encodedImage._encodedHeight);
self.timeStamp = encodedImage.Timestamp();
diff --git a/test/fake_decoder.cc b/test/fake_decoder.cc
index 2dc5b64..8bf4ba0 100644
--- a/test/fake_decoder.cc
+++ b/test/fake_decoder.cc
@@ -80,9 +80,9 @@
const CodecSpecificInfo* codec_specific_info,
int64_t render_time_ms) {
uint8_t value = 0;
- for (size_t i = 0; i < input._length; ++i) {
+ for (size_t i = 0; i < input.size(); ++i) {
uint8_t kStartCode[] = {0, 0, 0, 1};
- if (i < input._length - sizeof(kStartCode) &&
+ if (i < input.size() - sizeof(kStartCode) &&
!memcmp(&input._buffer[i], kStartCode, sizeof(kStartCode))) {
i += sizeof(kStartCode) + 1; // Skip start code and NAL header.
}
diff --git a/test/fake_encoder.cc b/test/fake_encoder.cc
index 06329c6..2e64cdb 100644
--- a/test/fake_encoder.cc
+++ b/test/fake_encoder.cc
@@ -304,7 +304,7 @@
}
RTPFragmentationHeader fragmentation;
if (current_idr_counter % kIdrFrequency == 0 &&
- encoded_image._length > kSpsSize + kPpsSize + 1) {
+ encoded_image.size() > kSpsSize + kPpsSize + 1) {
const size_t kNumSlices = 3;
fragmentation.VerifyAndAllocateFragmentationHeader(kNumSlices);
fragmentation.fragmentationOffset[0] = 0;
@@ -313,7 +313,7 @@
fragmentation.fragmentationLength[1] = kPpsSize;
fragmentation.fragmentationOffset[2] = kSpsSize + kPpsSize;
fragmentation.fragmentationLength[2] =
- encoded_image._length - (kSpsSize + kPpsSize);
+ encoded_image.size() - (kSpsSize + kPpsSize);
const size_t kSpsNalHeader = 0x67;
const size_t kPpsNalHeader = 0x68;
const size_t kIdrNalHeader = 0x65;
@@ -324,13 +324,13 @@
const size_t kNumSlices = 1;
fragmentation.VerifyAndAllocateFragmentationHeader(kNumSlices);
fragmentation.fragmentationOffset[0] = 0;
- fragmentation.fragmentationLength[0] = encoded_image._length;
+ fragmentation.fragmentationLength[0] = encoded_image.size();
const size_t kNalHeader = 0x41;
encoded_image._buffer[fragmentation.fragmentationOffset[0]] = kNalHeader;
}
uint8_t value = 0;
int fragment_counter = 0;
- for (size_t i = 0; i < encoded_image._length; ++i) {
+ for (size_t i = 0; i < encoded_image.size(); ++i) {
if (fragment_counter == fragmentation.fragmentationVectorSize ||
i != fragmentation.fragmentationOffset[fragment_counter]) {
encoded_image._buffer[i] = value++;
diff --git a/test/fake_vp8_decoder.cc b/test/fake_vp8_decoder.cc
index 7b0cea0..2311228 100644
--- a/test/fake_vp8_decoder.cc
+++ b/test/fake_vp8_decoder.cc
@@ -49,7 +49,7 @@
const CodecSpecificInfo* codec_specific_info,
int64_t render_time_ms) {
constexpr size_t kMinPayLoadHeaderLength = 10;
- if (input._length < kMinPayLoadHeaderLength) {
+ if (input.size() < kMinPayLoadHeaderLength) {
return WEBRTC_VIDEO_CODEC_ERROR;
}
ParseFakeVp8(input._buffer, &width_, &height_);
diff --git a/test/fake_vp8_encoder.cc b/test/fake_vp8_encoder.cc
index dfd4802..f0c953c 100644
--- a/test/fake_vp8_encoder.cc
+++ b/test/fake_vp8_encoder.cc
@@ -121,7 +121,7 @@
uint8_t stream_idx = encoded_image.SpatialIndex().value_or(0);
CodecSpecificInfo overrided_specific_info;
temporal_layers_[stream_idx]->UpdateLayerConfig(encoded_image.Timestamp());
- PopulateCodecSpecific(&overrided_specific_info, encoded_image._length,
+ PopulateCodecSpecific(&overrided_specific_info, encoded_image.size(),
encoded_image._frameType, stream_idx,
encoded_image.Timestamp());
diff --git a/video/buffered_frame_decryptor.cc b/video/buffered_frame_decryptor.cc
index 5b1f7f0..99dc742 100644
--- a/video/buffered_frame_decryptor.cc
+++ b/video/buffered_frame_decryptor.cc
@@ -87,7 +87,7 @@
}
RTC_CHECK_LE(bytes_written, max_plaintext_byte_size);
// Update the frame to contain just the written bytes.
- frame->SetSize(bytes_written);
+ frame->set_size(bytes_written);
// Indicate that all future fail to decrypt frames should be dropped.
if (!first_frame_decrypted_) {
diff --git a/video/send_statistics_proxy.cc b/video/send_statistics_proxy.cc
index 24e9641..e5e527f 100644
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@@ -959,7 +959,7 @@
}
}
- media_byte_rate_tracker_.AddSamples(encoded_image._length);
+ media_byte_rate_tracker_.AddSamples(encoded_image.size());
// Initialize to current since |is_limited_in_resolution| is only updated
// when an encoded frame is removed from the EncodedFrameMap.
diff --git a/video/video_replay.cc b/video/video_replay.cc
index 79d13eb..084abb9 100644
--- a/video/video_replay.cc
+++ b/video/video_replay.cc
@@ -225,8 +225,8 @@
bool /* missing_frames */,
const CodecSpecificInfo* /* codec_specific_info */,
int64_t /* render_time_ms */) override {
- if (fwrite(encoded_frame._buffer, 1, encoded_frame._length, file_) <
- encoded_frame._length) {
+ if (fwrite(encoded_frame.data(), 1, encoded_frame.size(), file_) <
+ encoded_frame.size()) {
RTC_LOG_ERR(LS_ERROR) << "fwrite of encoded frame failed.";
return WEBRTC_VIDEO_CODEC_ERROR;
}
