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

Deprecate the raw-pointer constructor of EncodedImage.

Browse Source 
Bug: webrtc:9378
Change-Id: I5591202aff3e9f22e902f52096ddb0592662789e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/185008
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#32175}
This commit is contained in:
Niels Möller
2020-09-23 12:45:17 +02:00
committed by Commit Bot
parent ced49e7b7c
commit 12f465cf94
9 changed files with 93 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/video/encoded_image.cc
View File

@ -61,7 +61,7 @@ void EncodedImageBuffer::Realloc(size_t size) {
size_ = size; size_ = size;
} }
EncodedImage::EncodedImage() : EncodedImage(nullptr, 0, 0) {} EncodedImage::EncodedImage() = default;
EncodedImage::EncodedImage(EncodedImage&&) = default; EncodedImage::EncodedImage(EncodedImage&&) = default;
EncodedImage::EncodedImage(const EncodedImage&) = default; EncodedImage::EncodedImage(const EncodedImage&) = default;

9
api/video/encoded_image.h
View File

@ -72,9 +72,8 @@ class RTC_EXPORT EncodedImage {
public: public:
EncodedImage(); EncodedImage();
EncodedImage(EncodedImage&&); EncodedImage(EncodedImage&&);
// Discouraged: potentially expensive.
EncodedImage(const EncodedImage&); EncodedImage(const EncodedImage&);
EncodedImage(uint8_t* buffer, size_t length, size_t capacity); RTC_DEPRECATED EncodedImage(uint8_t* buffer, size_t length, size_t capacity);
~EncodedImage(); ~EncodedImage();
@ -200,11 +199,11 @@ class RTC_EXPORT EncodedImage {
// TODO(bugs.webrtc.org/9378): We're transitioning to always owning the // TODO(bugs.webrtc.org/9378): We're transitioning to always owning the
// encoded data. // encoded data.
rtc::scoped_refptr<EncodedImageBufferInterface> encoded_data_; rtc::scoped_refptr<EncodedImageBufferInterface> encoded_data_;
size_t size_; // Size of encoded frame data. size_t size_ = 0; // Size of encoded frame data.
// Non-null when used with an un-owned buffer. // Non-null when used with an un-owned buffer.
uint8_t* buffer_; uint8_t* buffer_ = nullptr;
// Allocated size of _buffer; relevant only if it's non-null. // Allocated size of _buffer; relevant only if it's non-null.
size_t capacity_; size_t capacity_ = 0;
uint32_t timestamp_rtp_ = 0; uint32_t timestamp_rtp_ = 0;
absl::optional<int> spatial_index_; absl::optional<int> spatial_index_;
std::map<int, size_t> spatial_layer_frame_size_bytes_; std::map<int, size_t> spatial_layer_frame_size_bytes_;

13
test/configurable_frame_size_encoder.cc
View File

@ -27,12 +27,8 @@ namespace test {
ConfigurableFrameSizeEncoder::ConfigurableFrameSizeEncoder( ConfigurableFrameSizeEncoder::ConfigurableFrameSizeEncoder(
size_t max_frame_size) size_t max_frame_size)
: callback_(NULL), : callback_(NULL),
max_frame_size_(max_frame_size),
current_frame_size_(max_frame_size), current_frame_size_(max_frame_size),
buffer_(new uint8_t[max_frame_size]), codec_type_(kVideoCodecGeneric) {}
codec_type_(kVideoCodecGeneric) {
memset(buffer_.get(), 0, max_frame_size);
}
ConfigurableFrameSizeEncoder::~ConfigurableFrameSizeEncoder() {} ConfigurableFrameSizeEncoder::~ConfigurableFrameSizeEncoder() {}
@ -50,8 +46,10 @@ int32_t ConfigurableFrameSizeEncoder::InitEncode(
int32_t ConfigurableFrameSizeEncoder::Encode( int32_t ConfigurableFrameSizeEncoder::Encode(
const VideoFrame& inputImage, const VideoFrame& inputImage,
const std::vector<VideoFrameType>* frame_types) { const std::vector<VideoFrameType>* frame_types) {
EncodedImage encodedImage(buffer_.get(), current_frame_size_, EncodedImage encodedImage;
max_frame_size_); auto buffer = EncodedImageBuffer::Create(current_frame_size_);
memset(buffer->data(), 0, current_frame_size_);
encodedImage.SetEncodedData(buffer);
encodedImage._completeFrame = true; encodedImage._completeFrame = true;
encodedImage._encodedHeight = inputImage.height(); encodedImage._encodedHeight = inputImage.height();
encodedImage._encodedWidth = inputImage.width(); encodedImage._encodedWidth = inputImage.width();
@ -81,7 +79,6 @@ void ConfigurableFrameSizeEncoder::SetRates(
const RateControlParameters& parameters) {} const RateControlParameters& parameters) {}
int32_t ConfigurableFrameSizeEncoder::SetFrameSize(size_t size) { int32_t ConfigurableFrameSizeEncoder::SetFrameSize(size_t size) {
RTC_DCHECK_LE(size, max_frame_size_);
current_frame_size_ = size; current_frame_size_ = size;
return WEBRTC_VIDEO_CODEC_OK; return WEBRTC_VIDEO_CODEC_OK;
} }

2
test/configurable_frame_size_encoder.h
View File

@ -60,9 +60,7 @@ class ConfigurableFrameSizeEncoder : public VideoEncoder {
EncodedImageCallback* callback_; EncodedImageCallback* callback_;
absl::optional<std::function<void(void)>> post_encode_callback_; absl::optional<std::function<void(void)>> post_encode_callback_;
const size_t max_frame_size_;
size_t current_frame_size_; size_t current_frame_size_;
std::unique_ptr<uint8_t[]> buffer_;
VideoCodecType codec_type_; VideoCodecType codec_type_;
}; };

64
test/pc/e2e/analyzer/video/default_encoded_image_data_injector_unittest.cc
View File

@ -20,23 +20,28 @@ namespace webrtc {
namespace webrtc_pc_e2e { namespace webrtc_pc_e2e {
namespace { namespace {
rtc::Buffer CreateBufferOfSizeNFilledWithValuesFromX(size_t n, uint8_t x) { rtc::scoped_refptr<EncodedImageBuffer>
rtc::Buffer buffer(n); CreateEncodedImageBufferOfSizeNFilledWithValuesFromX(size_t n, uint8_t x) {
auto buffer = EncodedImageBuffer::Create(n);
for (size_t i = 0; i < n; ++i) { for (size_t i = 0; i < n; ++i) {
buffer[i] = static_cast<uint8_t>(x + i); buffer->data()[i] = static_cast<uint8_t>(x + i);
} }
return buffer; return buffer;
} }
} // namespace EncodedImage CreateEncodedImageOfSizeNFilledWithValuesFromX(size_t n,
uint8_t x) {
EncodedImage image;
image.SetEncodedData(
CreateEncodedImageBufferOfSizeNFilledWithValuesFromX(n, x));
return image;
}
TEST(DefaultEncodedImageDataInjector, InjectExtractDiscardFalse) { TEST(DefaultEncodedImageDataInjector, InjectExtractDiscardFalse) {
DefaultEncodedImageDataInjector injector; DefaultEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
source.SetTimestamp(123456789); source.SetTimestamp(123456789);
EncodedImageExtractionResult out = EncodedImageExtractionResult out =
@ -53,9 +58,7 @@ TEST(DefaultEncodedImageDataInjector, InjectExtractDiscardTrue) {
DefaultEncodedImageDataInjector injector; DefaultEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
source.SetTimestamp(123456789); source.SetTimestamp(123456789);
EncodedImageExtractionResult out = EncodedImageExtractionResult out =
@ -69,18 +72,14 @@ TEST(DefaultEncodedImageDataInjector, Inject3Extract3) {
DefaultEncodedImageDataInjector injector; DefaultEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
// 1st frame // 1st frame
EncodedImage source1(buffer1.data(), 10, 10); EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source1.SetTimestamp(123456710); source1.SetTimestamp(123456710);
// 2nd frame 1st spatial layer // 2nd frame 1st spatial layer
EncodedImage source2(buffer2.data(), 10, 10); EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456720); source2.SetTimestamp(123456720);
// 2nd frame 2nd spatial layer // 2nd frame 2nd spatial layer
EncodedImage source3(buffer3.data(), 10, 10); EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456720); source3.SetTimestamp(123456720);
EncodedImage intermediate1 = injector.InjectData(510, false, source1, 1); EncodedImage intermediate1 = injector.InjectData(510, false, source1, 1);
@ -113,15 +112,11 @@ TEST(DefaultEncodedImageDataInjector, InjectExtractFromConcatenated) {
DefaultEncodedImageDataInjector injector; DefaultEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
EncodedImage source1(buffer1.data(), 10, 10);
source1.SetTimestamp(123456710); source1.SetTimestamp(123456710);
EncodedImage source2(buffer2.data(), 10, 10); EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456710); source2.SetTimestamp(123456710);
EncodedImage source3(buffer3.data(), 10, 10); EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456710); source3.SetTimestamp(123456710);
// Inject id into 3 images with same frame id. // Inject id into 3 images with same frame id.
@ -137,8 +132,9 @@ TEST(DefaultEncodedImageDataInjector, InjectExtractFromConcatenated) {
concatenated_buffer.AppendData(intermediate1.data(), intermediate1.size()); concatenated_buffer.AppendData(intermediate1.data(), intermediate1.size());
concatenated_buffer.AppendData(intermediate2.data(), intermediate2.size()); concatenated_buffer.AppendData(intermediate2.data(), intermediate2.size());
concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size()); concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size());
EncodedImage concatenated(concatenated_buffer.data(), concatenated_length, EncodedImage concatenated;
concatenated_length); concatenated.SetEncodedData(EncodedImageBuffer::Create(
concatenated_buffer.data(), concatenated_length));
// Extract frame id from concatenated image // Extract frame id from concatenated image
EncodedImageExtractionResult out = injector.ExtractData(concatenated, 2); EncodedImageExtractionResult out = injector.ExtractData(concatenated, 2);
@ -157,15 +153,11 @@ TEST(DefaultEncodedImageDataInjector,
DefaultEncodedImageDataInjector injector; DefaultEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
EncodedImage source1(buffer1.data(), 10, 10);
source1.SetTimestamp(123456710); source1.SetTimestamp(123456710);
EncodedImage source2(buffer2.data(), 10, 10); EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456710); source2.SetTimestamp(123456710);
EncodedImage source3(buffer3.data(), 10, 10); EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456710); source3.SetTimestamp(123456710);
// Inject id into 3 images with same frame id. // Inject id into 3 images with same frame id.
@ -181,8 +173,9 @@ TEST(DefaultEncodedImageDataInjector,
concatenated_buffer.AppendData(intermediate1.data(), intermediate1.size()); concatenated_buffer.AppendData(intermediate1.data(), intermediate1.size());
concatenated_buffer.AppendData(intermediate2.data(), intermediate2.size()); concatenated_buffer.AppendData(intermediate2.data(), intermediate2.size());
concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size()); concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size());
EncodedImage concatenated(concatenated_buffer.data(), concatenated_length, EncodedImage concatenated;
concatenated_length); concatenated.SetEncodedData(EncodedImageBuffer::Create(
concatenated_buffer.data(), concatenated_length));
// Extract frame id from concatenated image // Extract frame id from concatenated image
EncodedImageExtractionResult out = injector.ExtractData(concatenated, 2); EncodedImageExtractionResult out = injector.ExtractData(concatenated, 2);
@ -192,5 +185,6 @@ TEST(DefaultEncodedImageDataInjector,
EXPECT_EQ(out.image.size(), 0ul); EXPECT_EQ(out.image.size(), 0ul);
} }
} // namespace
} // namespace webrtc_pc_e2e } // namespace webrtc_pc_e2e
} // namespace webrtc } // namespace webrtc

80
test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector_unittest.cc
View File

@ -20,21 +20,28 @@ namespace webrtc {
namespace webrtc_pc_e2e { namespace webrtc_pc_e2e {
namespace { namespace {
rtc::Buffer CreateBufferOfSizeNFilledWithValuesFromX(size_t n, uint8_t x) { rtc::scoped_refptr<EncodedImageBuffer>
rtc::Buffer buffer(n); CreateEncodedImageBufferOfSizeNFilledWithValuesFromX(size_t n, uint8_t x) {
auto buffer = EncodedImageBuffer::Create(n);
for (size_t i = 0; i < n; ++i) { for (size_t i = 0; i < n; ++i) {
buffer[i] = static_cast<uint8_t>(x + i); buffer->data()[i] = static_cast<uint8_t>(x + i);
} }
return buffer; return buffer;
} }
EncodedImage CreateEncodedImageOfSizeNFilledWithValuesFromX(size_t n,
uint8_t x) {
EncodedImage image;
image.SetEncodedData(
CreateEncodedImageBufferOfSizeNFilledWithValuesFromX(n, x));
return image;
}
TEST(SingleProcessEncodedImageDataInjector, InjectExtractDiscardFalse) { TEST(SingleProcessEncodedImageDataInjector, InjectExtractDiscardFalse) {
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
source.SetTimestamp(123456789); source.SetTimestamp(123456789);
EncodedImageExtractionResult out = EncodedImageExtractionResult out =
@ -53,9 +60,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectExtractDiscardTrue) {
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
source.SetTimestamp(123456789); source.SetTimestamp(123456789);
EncodedImageExtractionResult out = EncodedImageExtractionResult out =
@ -71,9 +76,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectWithUnsetSpatialLayerSizes) {
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
source.SetTimestamp(123456789); source.SetTimestamp(123456789);
EncodedImage intermediate = injector.InjectData(512, false, source, 1); EncodedImage intermediate = injector.InjectData(512, false, source, 1);
@ -97,9 +100,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectWithZeroSpatialLayerSizes) {
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
source.SetTimestamp(123456789); source.SetTimestamp(123456789);
EncodedImage intermediate = injector.InjectData(512, false, source, 1); EncodedImage intermediate = injector.InjectData(512, false, source, 1);
@ -126,18 +127,14 @@ TEST(SingleProcessEncodedImageDataInjector, Inject3Extract3) {
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
// 1st frame // 1st frame
EncodedImage source1(buffer1.data(), 10, 10); EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source1.SetTimestamp(123456710); source1.SetTimestamp(123456710);
// 2nd frame 1st spatial layer // 2nd frame 1st spatial layer
EncodedImage source2(buffer2.data(), 10, 10); EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456720); source2.SetTimestamp(123456720);
// 2nd frame 2nd spatial layer // 2nd frame 2nd spatial layer
EncodedImage source3(buffer3.data(), 10, 10); EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456720); source3.SetTimestamp(123456720);
EncodedImage intermediate1 = injector.InjectData(510, false, source1, 1); EncodedImage intermediate1 = injector.InjectData(510, false, source1, 1);
@ -176,15 +173,11 @@ TEST(SingleProcessEncodedImageDataInjector, InjectExtractFromConcatenated) {
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
EncodedImage source1(buffer1.data(), 10, 10);
source1.SetTimestamp(123456710); source1.SetTimestamp(123456710);
EncodedImage source2(buffer2.data(), 10, 10); EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456710); source2.SetTimestamp(123456710);
EncodedImage source3(buffer3.data(), 10, 10); EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456710); source3.SetTimestamp(123456710);
// Inject id into 3 images with same frame id. // Inject id into 3 images with same frame id.
@ -200,8 +193,9 @@ TEST(SingleProcessEncodedImageDataInjector, InjectExtractFromConcatenated) {
concatenated_buffer.AppendData(intermediate1.data(), intermediate1.size()); concatenated_buffer.AppendData(intermediate1.data(), intermediate1.size());
concatenated_buffer.AppendData(intermediate2.data(), intermediate2.size()); concatenated_buffer.AppendData(intermediate2.data(), intermediate2.size());
concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size()); concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size());
EncodedImage concatenated(concatenated_buffer.data(), concatenated_length, EncodedImage concatenated;
concatenated_length); concatenated.SetEncodedData(EncodedImageBuffer::Create(
concatenated_buffer.data(), concatenated_length));
concatenated.SetSpatialIndex(2); concatenated.SetSpatialIndex(2);
concatenated.SetSpatialLayerFrameSize(0, intermediate1.size()); concatenated.SetSpatialLayerFrameSize(0, intermediate1.size());
concatenated.SetSpatialLayerFrameSize(1, intermediate2.size()); concatenated.SetSpatialLayerFrameSize(1, intermediate2.size());
@ -229,15 +223,11 @@ TEST(SingleProcessEncodedImageDataInjector,
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(1); injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
EncodedImage source1(buffer1.data(), 10, 10);
source1.SetTimestamp(123456710); source1.SetTimestamp(123456710);
EncodedImage source2(buffer2.data(), 10, 10); EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456710); source2.SetTimestamp(123456710);
EncodedImage source3(buffer3.data(), 10, 10); EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456710); source3.SetTimestamp(123456710);
// Inject id into 3 images with same frame id. // Inject id into 3 images with same frame id.
@ -253,8 +243,10 @@ TEST(SingleProcessEncodedImageDataInjector,
concatenated_buffer.AppendData(intermediate1.data(), intermediate1.size()); concatenated_buffer.AppendData(intermediate1.data(), intermediate1.size());
concatenated_buffer.AppendData(intermediate2.data(), intermediate2.size()); concatenated_buffer.AppendData(intermediate2.data(), intermediate2.size());
concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size()); concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size());
EncodedImage concatenated(concatenated_buffer.data(), concatenated_length, EncodedImage concatenated;
concatenated_length); concatenated.SetEncodedData(EncodedImageBuffer::Create(
concatenated_buffer.data(), concatenated_length));
memcpy(concatenated.data(), concatenated_buffer.data(), concatenated_length);
concatenated.SetSpatialIndex(2); concatenated.SetSpatialIndex(2);
concatenated.SetSpatialLayerFrameSize(0, intermediate1.size()); concatenated.SetSpatialLayerFrameSize(0, intermediate1.size());
concatenated.SetSpatialLayerFrameSize(1, intermediate2.size()); concatenated.SetSpatialLayerFrameSize(1, intermediate2.size());
@ -277,9 +269,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectOnceExtractTwice) {
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(2); injector.Start(2);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
source.SetTimestamp(123456789); source.SetTimestamp(123456789);
EncodedImageExtractionResult out = EncodedImageExtractionResult out =
@ -323,9 +313,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectOnceExtractMoreThenExpected) {
SingleProcessEncodedImageDataInjector injector; SingleProcessEncodedImageDataInjector injector;
injector.Start(2); injector.Start(2);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1); EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
source.SetTimestamp(123456789); source.SetTimestamp(123456789);
EncodedImage modified = injector.InjectData(/*id=*/512, /*discard=*/false, EncodedImage modified = injector.InjectData(/*id=*/512, /*discard=*/false,

7
video/encoder_bitrate_adjuster_unittest.cc
View File

@ -100,9 +100,6 @@ class EncoderBitrateAdjusterTest : public ::testing::Test {
RTC_DCHECK_EQ(media_utilization_factors.size(), RTC_DCHECK_EQ(media_utilization_factors.size(),
network_utilization_factors.size()); network_utilization_factors.size());
constexpr size_t kMaxFrameSize = 100000;
uint8_t buffer[kMaxFrameSize];
const int64_t start_us = rtc::TimeMicros(); const int64_t start_us = rtc::TimeMicros();
while (rtc::TimeMicros() < while (rtc::TimeMicros() <
start_us + (duration_ms * rtc::kNumMicrosecsPerMillisec)) { start_us + (duration_ms * rtc::kNumMicrosecsPerMillisec)) {
@ -168,8 +165,8 @@ class EncoderBitrateAdjusterTest : public ::testing::Test {
? media_frame_size - network_frame_size_diff_bytes ? media_frame_size - network_frame_size_diff_bytes
: media_frame_size + network_frame_size_diff_bytes; : media_frame_size + network_frame_size_diff_bytes;
EncodedImage image(buffer, 0, kMaxFrameSize); EncodedImage image;
image.set_size(frame_size_bytes); image.SetEncodedData(EncodedImageBuffer::Create(frame_size_bytes));
image.SetSpatialIndex(si); image.SetSpatialIndex(si);
adjuster_->OnEncodedFrame(image, ti); adjuster_->OnEncodedFrame(image, ti);
sequence_idx = ++sequence_idx % kSequenceLength; sequence_idx = ++sequence_idx % kSequenceLength;

18
video/frame_encode_metadata_writer_unittest.cc
View File

@ -461,30 +461,34 @@ TEST(FrameEncodeMetadataWriterTest, CopiesPacketInfos) {
TEST(FrameEncodeMetadataWriterTest, DoesNotRewriteBitstreamWithoutCodecInfo) { TEST(FrameEncodeMetadataWriterTest, DoesNotRewriteBitstreamWithoutCodecInfo) {
uint8_t buffer[] = {1, 2, 3}; uint8_t buffer[] = {1, 2, 3};
EncodedImage image(buffer, sizeof(buffer), sizeof(buffer)); auto image_buffer = EncodedImageBuffer::Create(buffer, sizeof(buffer));
EncodedImage image;
image.SetEncodedData(image_buffer);
FakeEncodedImageCallback sink; FakeEncodedImageCallback sink;
FrameEncodeMetadataWriter encode_metadata_writer(&sink); FrameEncodeMetadataWriter encode_metadata_writer(&sink);
encode_metadata_writer.UpdateBitstream(nullptr, &image); encode_metadata_writer.UpdateBitstream(nullptr, &image);
EXPECT_EQ(image.data(), buffer); EXPECT_EQ(image.GetEncodedData(), image_buffer);
EXPECT_EQ(image.size(), sizeof(buffer)); EXPECT_EQ(image.size(), sizeof(buffer));
} }
TEST(FrameEncodeMetadataWriterTest, DoesNotRewriteVp8Bitstream) { TEST(FrameEncodeMetadataWriterTest, DoesNotRewriteVp8Bitstream) {
uint8_t buffer[] = {1, 2, 3}; uint8_t buffer[] = {1, 2, 3};
EncodedImage image(buffer, sizeof(buffer), sizeof(buffer)); auto image_buffer = EncodedImageBuffer::Create(buffer, sizeof(buffer));
EncodedImage image;
image.SetEncodedData(image_buffer);
CodecSpecificInfo codec_specific_info; CodecSpecificInfo codec_specific_info;
codec_specific_info.codecType = kVideoCodecVP8; codec_specific_info.codecType = kVideoCodecVP8;
FakeEncodedImageCallback sink; FakeEncodedImageCallback sink;
FrameEncodeMetadataWriter encode_metadata_writer(&sink); FrameEncodeMetadataWriter encode_metadata_writer(&sink);
encode_metadata_writer.UpdateBitstream(&codec_specific_info, &image); encode_metadata_writer.UpdateBitstream(&codec_specific_info, &image);
EXPECT_EQ(image.data(), buffer); EXPECT_EQ(image.GetEncodedData(), image_buffer);
EXPECT_EQ(image.size(), sizeof(buffer)); EXPECT_EQ(image.size(), sizeof(buffer));
} }
TEST(FrameEncodeMetadataWriterTest, RewritesH264BitstreamWithNonOptimalSps) { TEST(FrameEncodeMetadataWriterTest, RewritesH264BitstreamWithNonOptimalSps) {
uint8_t original_sps[] = {0, 0, 0, 1, H264::NaluType::kSps, const uint8_t kOriginalSps[] = {0, 0, 0, 1, H264::NaluType::kSps,
0x00, 0x00, 0x03, 0x03, 0xF4, 0x00, 0x00, 0x03, 0x03, 0xF4,
0x05, 0x03, 0xC7, 0xC0}; 0x05, 0x03, 0xC7, 0xC0};
const uint8_t kRewrittenSps[] = {0, 0, 0, 1, H264::NaluType::kSps, const uint8_t kRewrittenSps[] = {0, 0, 0, 1, H264::NaluType::kSps,
@ -492,7 +496,9 @@ TEST(FrameEncodeMetadataWriterTest, RewritesH264BitstreamWithNonOptimalSps) {
0x05, 0x03, 0xC7, 0xE0, 0x1B, 0x05, 0x03, 0xC7, 0xE0, 0x1B,
0x41, 0x10, 0x8D, 0x00}; 0x41, 0x10, 0x8D, 0x00};
EncodedImage image(original_sps, sizeof(original_sps), sizeof(original_sps)); EncodedImage image;
image.SetEncodedData(
EncodedImageBuffer::Create(kOriginalSps, sizeof(kOriginalSps)));
image._frameType = VideoFrameType::kVideoFrameKey; image._frameType = VideoFrameType::kVideoFrameKey;
CodecSpecificInfo codec_specific_info; CodecSpecificInfo codec_specific_info;

6
video/video_send_stream_tests.cc
View File

@ -3150,8 +3150,10 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
CodecSpecificInfo specifics; CodecSpecificInfo specifics;
specifics.codecType = kVideoCodecGeneric; specifics.codecType = kVideoCodecGeneric;
uint8_t buffer[16] = {0}; EncodedImage encoded;
EncodedImage encoded(buffer, sizeof(buffer), sizeof(buffer)); auto buffer = EncodedImageBuffer::Create(16);
memset(buffer->data(), 0, 16);
encoded.SetEncodedData(buffer);
encoded.SetTimestamp(input_image.timestamp()); encoded.SetTimestamp(input_image.timestamp());
encoded.capture_time_ms_ = input_image.render_time_ms(); encoded.capture_time_ms_ = input_image.render_time_ms();