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

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);
}
}