zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename EncodedImage::_buffer --> buffer_, and make private

Browse Source 
Bug: webrtc:9378
Change-Id: I0a0636077b270a7c73bafafb958132fa648aca70
Reviewed-on: https://webrtc-review.googlesource.com/c/117722
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26294}
This commit is contained in:
Niels Möller
2019-01-17 11:31:13 +01:00
committed by Commit Bot
parent 83ed89a45f
commit 24871e4cbe
24 changed files with 91 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -259,12 +259,12 @@ int32_t H264DecoderImpl::Decode(const EncodedImage& input_image,
// "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.size(), 0,
memset(input_image.data() + input_image.size(), 0,
EncodedImage::GetBufferPaddingBytes(kVideoCodecH264));
AVPacket packet;
av_init_packet(&packet);
packet.data = input_image._buffer;
packet.data = input_image.data();
if (input_image.size() >
static_cast<size_t>(std::numeric_limits<int>::max())) {
ReportError();

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

@ -127,7 +127,7 @@ static void RtpFragmentize(EncodedImage* encoded_image,
new_capacity = required_capacity;
}
encoded_image->set_buffer(new uint8_t[new_capacity], new_capacity);
encoded_image_buffer->reset(encoded_image->_buffer);
encoded_image_buffer->reset(encoded_image->data());
}
// Iterate layers and NAL units, note each NAL unit as a fragment and copy
@ -304,7 +304,7 @@ int32_t H264EncoderImpl::InitEncode(const VideoCodec* inst,
CalcBufferSize(VideoType::kI420, codec_.simulcastStream[idx].width,
codec_.simulcastStream[idx].height);
encoded_images_[i].set_buffer(new uint8_t[new_capacity], new_capacity);
encoded_image_buffers_[i].reset(encoded_images_[i]._buffer);
encoded_image_buffers_[i].reset(encoded_images_[i].data());
encoded_images_[i]._completeFrame = true;
encoded_images_[i]._encodedWidth = codec_.simulcastStream[idx].width;
encoded_images_[i]._encodedHeight = codec_.simulcastStream[idx].height;

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

@ -41,7 +41,7 @@ int PackHeader(uint8_t* buffer, MultiplexImageHeader header) {
return offset;
}
MultiplexImageHeader UnpackHeader(uint8_t* buffer) {
MultiplexImageHeader UnpackHeader(const uint8_t* buffer) {
MultiplexImageHeader header;
int offset = 0;
header.component_count = ByteReader<uint8_t>::ReadBigEndian(buffer + offset);
@ -95,7 +95,7 @@ int PackFrameHeader(uint8_t* buffer,
return offset;
}
MultiplexImageComponentHeader UnpackFrameHeader(uint8_t* buffer) {
MultiplexImageComponentHeader UnpackFrameHeader(const uint8_t* buffer) {
MultiplexImageComponentHeader frame_header;
int offset = 0;
@ -192,14 +192,14 @@ EncodedImage MultiplexEncodedImagePacker::PackAndRelease(
combined_image.set_size(bitstream_offset);
// header
header_offset = PackHeader(combined_image._buffer, header);
header_offset = PackHeader(combined_image.data(), header);
RTC_DCHECK_EQ(header.first_component_header_offset,
kMultiplexImageHeaderSize);
// Frame Header
for (size_t i = 0; i < images.size(); i++) {
int relative_offset = PackFrameHeader(
combined_image._buffer + header_offset, frame_headers[i]);
int relative_offset = PackFrameHeader(combined_image.data() + header_offset,
frame_headers[i]);
RTC_DCHECK_EQ(relative_offset, kMultiplexImageComponentHeaderSize);
header_offset = frame_headers[i].next_component_header_offset;
@ -212,16 +212,16 @@ EncodedImage MultiplexEncodedImagePacker::PackAndRelease(
// Augmenting Data
if (multiplex_image.augmenting_data_size != 0) {
memcpy(combined_image._buffer + header.augmenting_data_offset,
memcpy(combined_image.data() + header.augmenting_data_offset,
multiplex_image.augmenting_data.get(),
multiplex_image.augmenting_data_size);
}
// Bitstreams
for (size_t i = 0; i < images.size(); i++) {
PackBitstream(combined_image._buffer + frame_headers[i].bitstream_offset,
PackBitstream(combined_image.data() + frame_headers[i].bitstream_offset,
images[i]);
delete[] images[i].encoded_image._buffer;
delete[] images[i].encoded_image.data();
}
return combined_image;
@ -229,14 +229,14 @@ EncodedImage MultiplexEncodedImagePacker::PackAndRelease(
MultiplexImage MultiplexEncodedImagePacker::Unpack(
const EncodedImage& combined_image) {
const MultiplexImageHeader& header = UnpackHeader(combined_image._buffer);
const MultiplexImageHeader& header = UnpackHeader(combined_image.data());
std::vector<MultiplexImageComponentHeader> frame_headers;
int header_offset = header.first_component_header_offset;
while (header_offset > 0) {
frame_headers.push_back(
UnpackFrameHeader(combined_image._buffer + header_offset));
UnpackFrameHeader(combined_image.data() + header_offset));
header_offset = frame_headers.back().next_component_header_offset;
}
@ -246,7 +246,7 @@ MultiplexImage MultiplexEncodedImagePacker::Unpack(
augmenting_data =
std::unique_ptr<uint8_t[]>(new uint8_t[header.augmenting_data_size]);
memcpy(augmenting_data.get(),
combined_image._buffer + header.augmenting_data_offset,
combined_image.data() + header.augmenting_data_offset,
header.augmenting_data_size);
}
@ -263,7 +263,7 @@ MultiplexImage MultiplexEncodedImagePacker::Unpack(
encoded_image.SetTimestamp(combined_image.Timestamp());
encoded_image._frameType = frame_headers[i].frame_type;
encoded_image.set_buffer(
combined_image._buffer + frame_headers[i].bitstream_offset,
combined_image.data() + frame_headers[i].bitstream_offset,
static_cast<size_t>(frame_headers[i].bitstream_length));
const size_t padding =
EncodedImage::GetBufferPaddingBytes(image_component.codec_type);

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

@ -249,13 +249,13 @@ int MultiplexEncoderAdapter::Release() {
rtc::CritScope cs(&crit_);
for (auto& stashed_image : stashed_images_) {
for (auto& image_component : stashed_image.second.image_components) {
delete[] image_component.encoded_image._buffer;
delete[] image_component.encoded_image.data();
}
}
stashed_images_.clear();
if (combined_image_._buffer) {
delete[] combined_image_._buffer;
combined_image_._buffer = nullptr;
if (combined_image_.data()) {
delete[] combined_image_.data();
combined_image_.set_buffer(nullptr, 0);
}
return WEBRTC_VIDEO_CODEC_OK;
}
@ -302,8 +302,8 @@ EncodedImageCallback::Result MultiplexEncoderAdapter::OnEncodedImage(
// We have to send out those stashed frames, otherwise the delta frame
// dependency chain is broken.
if (combined_image_._buffer)
delete[] combined_image_._buffer;
if (combined_image_.data())
delete[] combined_image_.data();
combined_image_ =
MultiplexEncodedImagePacker::PackAndRelease(iter->second);

4
modules/video_coding/codecs/multiplex/test/multiplex_adapter_unittest.cc
View File

@ -278,7 +278,7 @@ TEST_P(TestMultiplexAdapter, CheckSingleFrameEncodedBitstream) {
EXPECT_EQ(1, unpacked_frame.component_count);
const MultiplexImageComponent& component = unpacked_frame.image_components[0];
EXPECT_EQ(0, component.component_index);
EXPECT_NE(nullptr, component.encoded_image._buffer);
EXPECT_NE(nullptr, component.encoded_image.data());
EXPECT_EQ(kVideoFrameKey, component.encoded_image._frameType);
}
@ -302,7 +302,7 @@ TEST_P(TestMultiplexAdapter, CheckDoubleFramesEncodedBitstream) {
const MultiplexImageComponent& component =
unpacked_frame.image_components[i];
EXPECT_EQ(i, component.component_index);
EXPECT_NE(nullptr, component.encoded_image._buffer);
EXPECT_NE(nullptr, component.encoded_image.data());
EXPECT_EQ(kVideoFrameKey, component.encoded_image._frameType);
}
}

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

@ -323,7 +323,7 @@ void VideoCodecTestFixtureImpl::H264KeyframeChecker::CheckEncodedFrame(
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]);
encoded_frame.data()[index.payload_start_offset]);
if (nalu_type == webrtc::H264::NaluType::kSps) {
contains_sps = true;
} else if (nalu_type == webrtc::H264::NaluType::kPps) {

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

@ -249,9 +249,9 @@ VideoProcessor::~VideoProcessor() {
// Deal with manual memory management of EncodedImage's.
for (size_t i = 0; i < num_simulcast_or_spatial_layers_; ++i) {
uint8_t* buffer = merged_encoded_frames_.at(i)._buffer;
if (buffer) {
delete[] buffer;
uint8_t* data = merged_encoded_frames_.at(i).data();
if (data) {
delete[] data;
}
}
}
@ -575,7 +575,7 @@ const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe(
RTC_CHECK(copied_buffer);
if (base_image.size()) {
RTC_CHECK(base_image._buffer);
RTC_CHECK(base_image.data());
memcpy(copied_buffer, base_image.data(), base_image.size());
}
memcpy(copied_buffer + base_image.size(), encoded_image.data(),

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

@ -109,10 +109,10 @@ class VideoProcessor {
const webrtc::EncodedImage& encoded_image,
const webrtc::CodecSpecificInfo* codec_specific_info)
: video_processor_(video_processor),
buffer_(encoded_image._buffer, encoded_image.size()),
buffer_(encoded_image.data(), encoded_image.size()),
encoded_image_(encoded_image),
codec_specific_info_(*codec_specific_info) {
encoded_image_._buffer = buffer_.data();
encoded_image_.set_buffer(buffer_.data(), buffer_.size());
}
bool Run() override {

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

@ -248,7 +248,7 @@ int LibvpxVp8Decoder::Decode(const EncodedImage& input_image,
iter = NULL;
}
uint8_t* buffer = input_image._buffer;
const uint8_t* buffer = input_image.data();
if (input_image.size() == 0) {
buffer = NULL; // Triggers full frame concealment.
}

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

@ -191,7 +191,7 @@ int LibvpxVp8Encoder::Release() {
while (!encoded_images_.empty()) {
EncodedImage& image = encoded_images_.back();
delete[] image._buffer;
delete[] image.data();
encoded_images_.pop_back();
}
while (!encoders_.empty()) {
@ -382,8 +382,8 @@ int LibvpxVp8Encoder::InitEncode(const VideoCodec* inst,
}
for (int i = 0; i < number_of_streams; ++i) {
// allocate memory for encoded image
if (encoded_images_[i]._buffer != NULL) {
delete[] encoded_images_[i]._buffer;
if (encoded_images_[i].data() != nullptr) {
delete[] encoded_images_[i].data();
}
size_t frame_capacity =
CalcBufferSize(VideoType::kI420, codec_.width, codec_.height);
@ -883,12 +883,12 @@ int LibvpxVp8Encoder::GetEncodedPartitions(const VideoFrame& input_image) {
if (pkt->data.frame.sz + length >
encoded_images_[encoder_idx].capacity()) {
uint8_t* buffer = new uint8_t[pkt->data.frame.sz + length];
memcpy(buffer, encoded_images_[encoder_idx]._buffer, length);
delete[] encoded_images_[encoder_idx]._buffer;
memcpy(buffer, encoded_images_[encoder_idx].data(), length);
delete[] encoded_images_[encoder_idx].data();
encoded_images_[encoder_idx].set_buffer(
buffer, pkt->data.frame.sz + length);
}
memcpy(&encoded_images_[encoder_idx]._buffer[length],
memcpy(&encoded_images_[encoder_idx].data()[length],
pkt->data.frame.buf, pkt->data.frame.sz);
encoded_images_[encoder_idx].set_size(
encoded_images_[encoder_idx].size() + pkt->data.frame.sz);

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

@ -187,9 +187,9 @@ VP9EncoderImpl::~VP9EncoderImpl() {
int VP9EncoderImpl::Release() {
int ret_val = WEBRTC_VIDEO_CODEC_OK;
if (encoded_image_._buffer != nullptr) {
delete[] encoded_image_._buffer;
encoded_image_._buffer = nullptr;
if (encoded_image_.data() != nullptr) {
delete[] encoded_image_.data();
encoded_image_.set_buffer(nullptr, 0);
}
if (encoder_ != nullptr) {
if (inited_) {
@ -392,8 +392,8 @@ int VP9EncoderImpl::InitEncode(const VideoCodec* inst,
is_svc_ = (num_spatial_layers_ > 1 || num_temporal_layers_ > 1);
// Allocate memory for encoded image
if (encoded_image_._buffer != nullptr) {
delete[] encoded_image_._buffer;
if (encoded_image_.data() != nullptr) {
delete[] encoded_image_.data();
}
size_t frame_capacity =
CalcBufferSize(VideoType::kI420, codec_.width, codec_.height);
@ -1258,11 +1258,11 @@ int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) {
}
if (pkt->data.frame.sz > encoded_image_.capacity()) {
delete[] encoded_image_._buffer;
delete[] encoded_image_.data();
encoded_image_.set_buffer(new uint8_t[pkt->data.frame.sz],
pkt->data.frame.sz);
}
memcpy(encoded_image_._buffer, pkt->data.frame.buf, pkt->data.frame.sz);
memcpy(encoded_image_.data(), pkt->data.frame.buf, pkt->data.frame.sz);
encoded_image_.set_size(pkt->data.frame.sz);
const bool is_key_frame =
@ -1431,7 +1431,7 @@ int VP9DecoderImpl::Decode(const EncodedImage& input_image,
}
vpx_codec_iter_t iter = nullptr;
vpx_image_t* img;
uint8_t* buffer = input_image._buffer;
const uint8_t* buffer = input_image.data();
if (input_image.size() == 0) {
buffer = nullptr; // Triggers full frame concealment.
}