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

Rename EncodedImage::_length --> size_, and make private.

Browse Source 
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}
This commit is contained in:
Niels Möller 2019-01-15 08:50:01 +01:00 committed by Commit Bot
parent 7491e8f17b
commit 77536a2b81
43 changed files with 153 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
api/media_transport_interface.cc
View File

@ -129,11 +129,10 @@ MediaTransportEncodedVideoFrame::MediaTransportEncodedVideoFrame(
}
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());
}
}

16
api/test/loopback_media_transport_unittest.cc
View File

@ -105,8 +105,8 @@ TEST(LoopbackMediaTransport, VideoDeliveredToSink) {
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 @@ TEST(LoopbackMediaTransport, VideoDeliveredToSink) {
.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);

4
api/video/encoded_image.cc
View File

@ -31,8 +31,8 @@ EncodedImage::EncodedImage() : EncodedImage(nullptr, 0, 0) {}
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) {

7
api/video/encoded_image.h
View File

@ -67,10 +67,10 @@ class RTC_EXPORT EncodedImage {
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 @@ class RTC_EXPORT EncodedImage {
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 @@ class RTC_EXPORT EncodedImage {
} 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_;

4
call/rtp_video_sender.cc
View File

@ -349,7 +349,7 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage(
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 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage(
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);

13
call/rtp_video_sender_unittest.cc
View File

@ -144,8 +144,8 @@ TEST_P(RtpVideoSenderTest, SendOnOneModule) {
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 @@ TEST_P(RtpVideoSenderTest, SendSimulcastSetActive) {
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 @@ TEST_P(RtpVideoSenderTest, SendSimulcastSetActiveModules) {
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);

14
modules/video_coding/codecs/h264/h264_decoder_impl.cc
View File

@ -241,7 +241,7 @@ int32_t H264DecoderImpl::Decode(const EncodedImage& input_image,
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 @@ int32_t H264DecoderImpl::Decode(const EncodedImage& input_image,
// 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 @@ int32_t H264DecoderImpl::Decode(const EncodedImage& input_image,
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);

16
modules/video_coding/codecs/h264/h264_encoder_impl.cc
View File

@ -135,7 +135,7 @@ static void RtpFragmentize(EncodedImage* encoded_image,
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 @@ static void RtpFragmentize(EncodedImage* encoded_image,
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 @@ int32_t H264EncoderImpl::InitEncode(const VideoCodec* inst,
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 @@ int32_t H264EncoderImpl::Encode(const VideoFrame& input_frame,
// 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.

11
modules/video_coding/codecs/multiplex/multiplex_encoded_image_packer.cc
View File

@ -128,7 +128,7 @@ MultiplexImageComponentHeader UnpackFrameHeader(uint8_t* buffer) {
}
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 @@ EncodedImage MultiplexEncodedImagePacker::PackAndRelease(
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 @@ EncodedImage MultiplexEncodedImagePacker::PackAndRelease(
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 @@ MultiplexImage MultiplexEncodedImagePacker::Unpack(
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;

8
modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
View File

@ -275,9 +275,11 @@ EncodedImageCallback::Result MultiplexEncoderAdapter::OnEncodedImage(
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 =

3
modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
View File

@ -320,8 +320,7 @@ void VideoCodecTestFixtureImpl::H264KeyframeChecker::CheckEncodedFrame(
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]);

6
modules/video_coding/codecs/test/videocodec_test_libvpx.cc
View File

@ -45,11 +45,9 @@ class QpFrameChecker : public VideoCodecTestFixture::EncodedFrameChecker {
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();
}

25
modules/video_coding/codecs/test/videoprocessor.cc
View File

@ -51,8 +51,7 @@ size_t GetMaxNaluSizeBytes(const EncodedImage& encoded_frame,
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 @@ void VideoProcessor::FrameEncoded(
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 @@ const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe(
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 webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe(
}
}
}
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;

2
modules/video_coding/codecs/test/videoprocessor.h
View File

@ -109,7 +109,7 @@ class VideoProcessor {
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();

6
modules/video_coding/codecs/vp8/libvpx_vp8_decoder.cc
View File

@ -161,7 +161,7 @@ int LibvpxVp8Decoder::Decode(const EncodedImage& input_image,
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 @@ int LibvpxVp8Decoder::Decode(const EncodedImage& input_image,
}
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) {

16
modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
View File

@ -861,7 +861,7 @@ void LibvpxVp8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
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 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
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 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
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 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
}
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 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
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 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
} 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);

4
modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
View File

@ -98,8 +98,8 @@ class TestVp8Impl : public VideoCodecUnitTest {
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.";
}
};

2
modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
View File

@ -243,7 +243,7 @@ TEST_F(TestVp9Impl, ParserQpEqualsEncodedQp) {
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);
}

16
modules/video_coding/codecs/vp9/vp9_impl.cc
View File

@ -1263,7 +1263,7 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
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 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
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 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
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 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
}
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 @@ void VP9EncoderImpl::DeliverBufferedFrame(bool end_of_picture) {
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 @@ int VP9DecoderImpl::Decode(const EncodedImage& input_image,
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;
}

2
modules/video_coding/encoded_frame.cc
View File

@ -52,7 +52,7 @@ void VCMEncodedFrame::Reset() {
_encodedHeight = 0;
_completeFrame = false;
_missingFrame = false;
_length = 0;
set_size(0);
_codecSpecificInfo.codecType = kVideoCodecGeneric;
_codec = kVideoCodecGeneric;
rotation_ = kVideoRotation_0;

8
modules/video_coding/frame_buffer.cc
View File

@ -138,8 +138,8 @@ VCMFrameBufferEnum VCMFrameBuffer::InsertPacket(
} 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 @@ int VCMFrameBuffer::NumPackets() const {
void VCMFrameBuffer::Reset() {
TRACE_EVENT0("webrtc", "VCMFrameBuffer::Reset");
_length = 0;
set_size(0);
_sessionInfo.Reset();
_payloadType = 0;
_nackCount = 0;
@ -265,7 +265,7 @@ VCMFrameBufferStateEnum VCMFrameBuffer::GetState() const {
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();

8
modules/video_coding/frame_buffer2_unittest.cc
View File

@ -91,10 +91,6 @@ class FrameObjectFake : public EncodedFrame {
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 @@ class TestFrameBuffer2 : public ::testing::Test {
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 @@ TEST_F(TestFrameBuffer2, StatsCallback) {
{
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);

7
modules/video_coding/frame_object.cc
View File

@ -139,11 +139,6 @@ int64_t RtpFrameObject::RenderTime() const {
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 @@ void RtpFrameObject::AllocateBitstreamBuffer(size_t frame_size) {
set_buffer(new uint8_t[new_size], new_size);
}
_length = frame_size;
set_size(frame_size);
}
} // namespace video_coding

1
modules/video_coding/frame_object.h
View File

@ -40,7 +40,6 @@ class RtpFrameObject : public EncodedFrame {
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;

2
modules/video_coding/generic_encoder.cc
View File

@ -327,7 +327,7 @@ void VCMEncodedFrameCallback::FillTimingInfo(size_t simulcast_svc_idx,
// 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;
}

12
modules/video_coding/generic_encoder_unittest.cc
View File

@ -82,6 +82,7 @@ std::vector<std::vector<FrameType>> GetTimingFrames(
{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 @@ std::vector<std::vector<FrameType>> GetTimingFrames(
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 @@ TEST(TestVCMEncodedFrameCallback, NoTimingFrameIfNoEncodeStartTime) {
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 @@ TEST(TestVCMEncodedFrameCallback, AdjustsCaptureTimeForInternalSourceEncoder) {
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;

10
modules/video_coding/utility/ivf_file_writer.cc
View File

@ -160,7 +160,7 @@ bool IvfFileWriter::WriteFrame(const EncodedImage& encoded_image,
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 @@ bool IvfFileWriter::WriteFrame(const EncodedImage& encoded_image,
}
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;

4
modules/video_coding/utility/ivf_file_writer_unittest.cc
View File

@ -41,11 +41,11 @@ class IvfFileWriterTest : public ::testing::Test {
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 {

12
modules/video_coding/utility/simulcast_test_fixture_impl.cc
View File

@ -85,18 +85,18 @@ class SimulcastTestFixtureImpl::TestEncodedImageCallback
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 @@ void SimulcastTestFixtureImpl::TestDecodeWidthHeightSet() {
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);
}));

2
modules/video_coding/video_packet_buffer_unittest.cc
View File

@ -643,7 +643,7 @@ TEST_P(TestPacketBufferH264Parameterized, GetBitstreamBufferPadding) {
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);

2
modules/video_coding/video_sender_unittest.cc
View File

@ -104,7 +104,7 @@ class EncodedImageCallbackImpl : public EncodedImageCallback {
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());
}

21
sdk/android/src/jni/android_media_decoder.cc
View File

@ -360,7 +360,7 @@ int32_t MediaCodecVideoDecoder::Decode(
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 @@ int32_t MediaCodecVideoDecoder::Decode(
}
key_frame_required_ = false;
}
if (inputImage._length == 0) {
if (inputImage.size() == 0) {
return WEBRTC_VIDEO_CODEC_ERROR;
}
@ -476,35 +476,34 @@ int32_t MediaCodecVideoDecoder::DecodeOnCodecThread(
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 @@ int32_t MediaCodecVideoDecoder::DecodeOnCodecThread(
// 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";

2
sdk/android/src/jni/android_media_encoder.cc
View File

@ -1047,7 +1047,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
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) {

4
sdk/android/src/jni/encoded_image.cc
View File

@ -27,8 +27,8 @@ ScopedJavaLocalRef<jobject> NativeToJavaFrameType(JNIEnv* env,
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;

8
sdk/android/src/jni/video_decoder_wrapper.cc
View File

@ -237,21 +237,21 @@ absl::optional<uint8_t> VideoDecoderWrapper::ParseQP(
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;

6
sdk/objc/api/peerconnection/RTCEncodedImage+Private.mm
View File

@ -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();

4
test/fake_decoder.cc
View File

@ -80,9 +80,9 @@ int32_t FakeH264Decoder::Decode(const EncodedImage& input,
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.
}

8
test/fake_encoder.cc
View File

@ -304,7 +304,7 @@ EncodedImageCallback::Result FakeH264Encoder::OnEncodedImage(
}
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 @@ EncodedImageCallback::Result FakeH264Encoder::OnEncodedImage(
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 @@ EncodedImageCallback::Result FakeH264Encoder::OnEncodedImage(
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++;

2
test/fake_vp8_decoder.cc
View File

@ -49,7 +49,7 @@ int32_t FakeVp8Decoder::Decode(const EncodedImage& input,
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_);

2
test/fake_vp8_encoder.cc
View File

@ -121,7 +121,7 @@ EncodedImageCallback::Result FakeVP8Encoder::OnEncodedImage(
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());

2
video/buffered_frame_decryptor.cc
View File

@ -87,7 +87,7 @@ BufferedFrameDecryptor::FrameDecision BufferedFrameDecryptor::DecryptFrame(
}
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_) {

2
video/send_statistics_proxy.cc
View File

@ -959,7 +959,7 @@ void SendStatisticsProxy::OnSendEncodedImage(
}
}
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.

4
video/video_replay.cc
View File

@ -225,8 +225,8 @@ class DecoderBitstreamFileWriter : public test::FakeDecoder {
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;
}