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;
}
EncodedImage::EncodedImage() : EncodedImage(nullptr, 0, 0) {}
EncodedImage::EncodedImage() = default;
EncodedImage::EncodedImage(EncodedImage&&) = default;
EncodedImage::EncodedImage(const EncodedImage&) = default;

9
api/video/encoded_image.h
View File

@ -72,9 +72,8 @@ class RTC_EXPORT EncodedImage {
public:
EncodedImage();
EncodedImage(EncodedImage&&);
// Discouraged: potentially expensive.
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();
@ -200,11 +199,11 @@ class RTC_EXPORT EncodedImage {
// TODO(bugs.webrtc.org/9378): We're transitioning to always owning the
// 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.
uint8_t* buffer_;
uint8_t* buffer_ = nullptr;
// Allocated size of _buffer; relevant only if it's non-null.
size_t capacity_;
size_t capacity_ = 0;
uint32_t timestamp_rtp_ = 0;
absl::optional<int> spatial_index_;
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(
size_t max_frame_size)
: callback_(NULL),
max_frame_size_(max_frame_size),
current_frame_size_(max_frame_size),
buffer_(new uint8_t[max_frame_size]),
codec_type_(kVideoCodecGeneric) {
memset(buffer_.get(), 0, max_frame_size);
}
codec_type_(kVideoCodecGeneric) {}
ConfigurableFrameSizeEncoder::~ConfigurableFrameSizeEncoder() {}
@ -50,8 +46,10 @@ int32_t ConfigurableFrameSizeEncoder::InitEncode(
int32_t ConfigurableFrameSizeEncoder::Encode(
const VideoFrame& inputImage,
const std::vector<VideoFrameType>* frame_types) {
EncodedImage encodedImage(buffer_.get(), current_frame_size_,
max_frame_size_);
EncodedImage encodedImage;
auto buffer = EncodedImageBuffer::Create(current_frame_size_);
memset(buffer->data(), 0, current_frame_size_);
encodedImage.SetEncodedData(buffer);
encodedImage._completeFrame = true;
encodedImage._encodedHeight = inputImage.height();
encodedImage._encodedWidth = inputImage.width();
@ -81,7 +79,6 @@ void ConfigurableFrameSizeEncoder::SetRates(
const RateControlParameters& parameters) {}
int32_t ConfigurableFrameSizeEncoder::SetFrameSize(size_t size) {
RTC_DCHECK_LE(size, max_frame_size_);
current_frame_size_ = size;
return WEBRTC_VIDEO_CODEC_OK;
}

2
test/configurable_frame_size_encoder.h
View File

@ -60,9 +60,7 @@ class ConfigurableFrameSizeEncoder : public VideoEncoder {
EncodedImageCallback* callback_;
absl::optional<std::function<void(void)>> post_encode_callback_;
const size_t max_frame_size_;
size_t current_frame_size_;
std::unique_ptr<uint8_t[]> buffer_;
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 {
rtc::Buffer CreateBufferOfSizeNFilledWithValuesFromX(size_t n, uint8_t x) {
rtc::Buffer buffer(n);
rtc::scoped_refptr<EncodedImageBuffer>
CreateEncodedImageBufferOfSizeNFilledWithValuesFromX(size_t n, uint8_t x) {
auto buffer = EncodedImageBuffer::Create(n);
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;
}
} // namespace
EncodedImage CreateEncodedImageOfSizeNFilledWithValuesFromX(size_t n,
uint8_t x) {
EncodedImage image;
image.SetEncodedData(
CreateEncodedImageBufferOfSizeNFilledWithValuesFromX(n, x));
return image;
}
TEST(DefaultEncodedImageDataInjector, InjectExtractDiscardFalse) {
DefaultEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source.SetTimestamp(123456789);
EncodedImageExtractionResult out =
@ -53,9 +58,7 @@ TEST(DefaultEncodedImageDataInjector, InjectExtractDiscardTrue) {
DefaultEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source.SetTimestamp(123456789);
EncodedImageExtractionResult out =
@ -69,18 +72,14 @@ TEST(DefaultEncodedImageDataInjector, Inject3Extract3) {
DefaultEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
// 1st frame
EncodedImage source1(buffer1.data(), 10, 10);
EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source1.SetTimestamp(123456710);
// 2nd frame 1st spatial layer
EncodedImage source2(buffer2.data(), 10, 10);
EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456720);
// 2nd frame 2nd spatial layer
EncodedImage source3(buffer3.data(), 10, 10);
EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456720);
EncodedImage intermediate1 = injector.InjectData(510, false, source1, 1);
@ -113,15 +112,11 @@ TEST(DefaultEncodedImageDataInjector, InjectExtractFromConcatenated) {
DefaultEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
EncodedImage source1(buffer1.data(), 10, 10);
EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source1.SetTimestamp(123456710);
EncodedImage source2(buffer2.data(), 10, 10);
EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456710);
EncodedImage source3(buffer3.data(), 10, 10);
EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456710);
// 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(intermediate2.data(), intermediate2.size());
concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size());
EncodedImage concatenated(concatenated_buffer.data(), concatenated_length,
concatenated_length);
EncodedImage concatenated;
concatenated.SetEncodedData(EncodedImageBuffer::Create(
concatenated_buffer.data(), concatenated_length));
// Extract frame id from concatenated image
EncodedImageExtractionResult out = injector.ExtractData(concatenated, 2);
@ -157,15 +153,11 @@ TEST(DefaultEncodedImageDataInjector,
DefaultEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
EncodedImage source1(buffer1.data(), 10, 10);
EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source1.SetTimestamp(123456710);
EncodedImage source2(buffer2.data(), 10, 10);
EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456710);
EncodedImage source3(buffer3.data(), 10, 10);
EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456710);
// 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(intermediate2.data(), intermediate2.size());
concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size());
EncodedImage concatenated(concatenated_buffer.data(), concatenated_length,
concatenated_length);
EncodedImage concatenated;
concatenated.SetEncodedData(EncodedImageBuffer::Create(
concatenated_buffer.data(), concatenated_length));
// Extract frame id from concatenated image
EncodedImageExtractionResult out = injector.ExtractData(concatenated, 2);
@ -192,5 +185,6 @@ TEST(DefaultEncodedImageDataInjector,
EXPECT_EQ(out.image.size(), 0ul);
}
} // namespace
} // namespace webrtc_pc_e2e
} // 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 {
rtc::Buffer CreateBufferOfSizeNFilledWithValuesFromX(size_t n, uint8_t x) {
rtc::Buffer buffer(n);
rtc::scoped_refptr<EncodedImageBuffer>
CreateEncodedImageBufferOfSizeNFilledWithValuesFromX(size_t n, uint8_t x) {
auto buffer = EncodedImageBuffer::Create(n);
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;
}
EncodedImage CreateEncodedImageOfSizeNFilledWithValuesFromX(size_t n,
uint8_t x) {
EncodedImage image;
image.SetEncodedData(
CreateEncodedImageBufferOfSizeNFilledWithValuesFromX(n, x));
return image;
}
TEST(SingleProcessEncodedImageDataInjector, InjectExtractDiscardFalse) {
SingleProcessEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source.SetTimestamp(123456789);
EncodedImageExtractionResult out =
@ -53,9 +60,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectExtractDiscardTrue) {
SingleProcessEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source.SetTimestamp(123456789);
EncodedImageExtractionResult out =
@ -71,9 +76,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectWithUnsetSpatialLayerSizes) {
SingleProcessEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source.SetTimestamp(123456789);
EncodedImage intermediate = injector.InjectData(512, false, source, 1);
@ -97,9 +100,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectWithZeroSpatialLayerSizes) {
SingleProcessEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source.SetTimestamp(123456789);
EncodedImage intermediate = injector.InjectData(512, false, source, 1);
@ -126,18 +127,14 @@ TEST(SingleProcessEncodedImageDataInjector, Inject3Extract3) {
SingleProcessEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
// 1st frame
EncodedImage source1(buffer1.data(), 10, 10);
EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source1.SetTimestamp(123456710);
// 2nd frame 1st spatial layer
EncodedImage source2(buffer2.data(), 10, 10);
EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456720);
// 2nd frame 2nd spatial layer
EncodedImage source3(buffer3.data(), 10, 10);
EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456720);
EncodedImage intermediate1 = injector.InjectData(510, false, source1, 1);
@ -176,15 +173,11 @@ TEST(SingleProcessEncodedImageDataInjector, InjectExtractFromConcatenated) {
SingleProcessEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
EncodedImage source1(buffer1.data(), 10, 10);
EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source1.SetTimestamp(123456710);
EncodedImage source2(buffer2.data(), 10, 10);
EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456710);
EncodedImage source3(buffer3.data(), 10, 10);
EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456710);
// 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(intermediate2.data(), intermediate2.size());
concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size());
EncodedImage concatenated(concatenated_buffer.data(), concatenated_length,
concatenated_length);
EncodedImage concatenated;
concatenated.SetEncodedData(EncodedImageBuffer::Create(
concatenated_buffer.data(), concatenated_length));
concatenated.SetSpatialIndex(2);
concatenated.SetSpatialLayerFrameSize(0, intermediate1.size());
concatenated.SetSpatialLayerFrameSize(1, intermediate2.size());
@ -229,15 +223,11 @@ TEST(SingleProcessEncodedImageDataInjector,
SingleProcessEncodedImageDataInjector injector;
injector.Start(1);
rtc::Buffer buffer1 = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
rtc::Buffer buffer2 = CreateBufferOfSizeNFilledWithValuesFromX(10, 11);
rtc::Buffer buffer3 = CreateBufferOfSizeNFilledWithValuesFromX(10, 21);
EncodedImage source1(buffer1.data(), 10, 10);
EncodedImage source1 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source1.SetTimestamp(123456710);
EncodedImage source2(buffer2.data(), 10, 10);
EncodedImage source2 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 11);
source2.SetTimestamp(123456710);
EncodedImage source3(buffer3.data(), 10, 10);
EncodedImage source3 = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 21);
source3.SetTimestamp(123456710);
// 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(intermediate2.data(), intermediate2.size());
concatenated_buffer.AppendData(intermediate3.data(), intermediate3.size());
EncodedImage concatenated(concatenated_buffer.data(), concatenated_length,
concatenated_length);
EncodedImage concatenated;
concatenated.SetEncodedData(EncodedImageBuffer::Create(
concatenated_buffer.data(), concatenated_length));
memcpy(concatenated.data(), concatenated_buffer.data(), concatenated_length);
concatenated.SetSpatialIndex(2);
concatenated.SetSpatialLayerFrameSize(0, intermediate1.size());
concatenated.SetSpatialLayerFrameSize(1, intermediate2.size());
@ -277,9 +269,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectOnceExtractTwice) {
SingleProcessEncodedImageDataInjector injector;
injector.Start(2);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source.SetTimestamp(123456789);
EncodedImageExtractionResult out =
@ -323,9 +313,7 @@ TEST(SingleProcessEncodedImageDataInjector, InjectOnceExtractMoreThenExpected) {
SingleProcessEncodedImageDataInjector injector;
injector.Start(2);
rtc::Buffer buffer = CreateBufferOfSizeNFilledWithValuesFromX(10, 1);
EncodedImage source(buffer.data(), 10, 10);
EncodedImage source = CreateEncodedImageOfSizeNFilledWithValuesFromX(10, 1);
source.SetTimestamp(123456789);
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(),
network_utilization_factors.size());
constexpr size_t kMaxFrameSize = 100000;
uint8_t buffer[kMaxFrameSize];
const int64_t start_us = rtc::TimeMicros();
while (rtc::TimeMicros() <
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;
EncodedImage image(buffer, 0, kMaxFrameSize);
image.set_size(frame_size_bytes);
EncodedImage image;
image.SetEncodedData(EncodedImageBuffer::Create(frame_size_bytes));
image.SetSpatialIndex(si);
adjuster_->OnEncodedFrame(image, ti);
sequence_idx = ++sequence_idx % kSequenceLength;

22
video/frame_encode_metadata_writer_unittest.cc
View File

@ -461,38 +461,44 @@ TEST(FrameEncodeMetadataWriterTest, CopiesPacketInfos) {
TEST(FrameEncodeMetadataWriterTest, DoesNotRewriteBitstreamWithoutCodecInfo) {
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;
FrameEncodeMetadataWriter encode_metadata_writer(&sink);
encode_metadata_writer.UpdateBitstream(nullptr, &image);
EXPECT_EQ(image.data(), buffer);
EXPECT_EQ(image.GetEncodedData(), image_buffer);
EXPECT_EQ(image.size(), sizeof(buffer));
}
TEST(FrameEncodeMetadataWriterTest, DoesNotRewriteVp8Bitstream) {
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;
codec_specific_info.codecType = kVideoCodecVP8;
FakeEncodedImageCallback sink;
FrameEncodeMetadataWriter encode_metadata_writer(&sink);
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));
}
TEST(FrameEncodeMetadataWriterTest, RewritesH264BitstreamWithNonOptimalSps) {
uint8_t original_sps[] = {0, 0, 0, 1, H264::NaluType::kSps,
0x00, 0x00, 0x03, 0x03, 0xF4,
0x05, 0x03, 0xC7, 0xC0};
const uint8_t kOriginalSps[] = {0, 0, 0, 1, H264::NaluType::kSps,
0x00, 0x00, 0x03, 0x03, 0xF4,
0x05, 0x03, 0xC7, 0xC0};
const uint8_t kRewrittenSps[] = {0, 0, 0, 1, H264::NaluType::kSps,
0x00, 0x00, 0x03, 0x03, 0xF4,
0x05, 0x03, 0xC7, 0xE0, 0x1B,
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;
CodecSpecificInfo codec_specific_info;

6
video/video_send_stream_tests.cc
View File

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