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

Pass webrtc::Environment when constructing video encoders in video/ tests

Browse Source 
Bug: webrtc:15860
Change-Id: I44725bddfb5c80d94ad29406c2b0cab013595ce3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/343762
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41954}
This commit is contained in:
Danil Chapovalov 2024-03-22 13:33:59 +01:00 committed by WebRTC LUCI CQ
parent 426b5e7ea1
commit be9d13a305
14 changed files with 145 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
modules/video_coding/codecs/h264/h264.cc
View File

@ -121,6 +121,18 @@ std::vector<SdpVideoFormat> SupportedH264DecoderCodecs() {
return supportedCodecs;
}
H264EncoderSettings H264EncoderSettings::Parse(const SdpVideoFormat& format) {
if (auto it = format.parameters.find(cricket::kH264FmtpPacketizationMode);
it != format.parameters.end()) {
if (it->second == "0") {
return {.packetization_mode = H264PacketizationMode::SingleNalUnit};
} else if (it->second == "1") {
return {.packetization_mode = H264PacketizationMode::NonInterleaved};
}
}
return {};
}
absl::Nonnull<std::unique_ptr<VideoEncoder>> CreateH264Encoder(
const Environment& env,
H264EncoderSettings settings) {

4
modules/video_coding/codecs/h264/include/h264.h
View File

@ -64,6 +64,10 @@ class RTC_EXPORT H264Encoder : public VideoEncoder {
};
struct H264EncoderSettings {
// Use factory function rather than constructor to allow to create
// `H264EncoderSettings` with designated initializers.
static H264EncoderSettings Parse(const SdpVideoFormat& format);
H264PacketizationMode packetization_mode =
H264PacketizationMode::NonInterleaved;
};

50
video/end_to_end_tests/codec_tests.cc
View File

@ -123,7 +123,9 @@ class CodecObserver : public test::EndToEndTest,
TEST_F(CodecEndToEndTest, SendsAndReceivesVP8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
test::FunctionVideoDecoderFactory decoder_factory(
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Decoder(env);
@ -135,7 +137,9 @@ TEST_F(CodecEndToEndTest, SendsAndReceivesVP8) {
TEST_F(CodecEndToEndTest, SendsAndReceivesVP8Rotation90) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
test::FunctionVideoDecoderFactory decoder_factory(
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Decoder(env);
@ -148,7 +152,9 @@ TEST_F(CodecEndToEndTest, SendsAndReceivesVP8Rotation90) {
#if defined(RTC_ENABLE_VP9)
TEST_F(CodecEndToEndTest, SendsAndReceivesVP9) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
test::FunctionVideoDecoderFactory decoder_factory(
[]() { return VP9Decoder::Create(); });
CodecObserver test(500, kVideoRotation_0, absl::nullopt, "VP9",
@ -158,7 +164,9 @@ TEST_F(CodecEndToEndTest, SendsAndReceivesVP9) {
TEST_F(CodecEndToEndTest, SendsAndReceivesVP9VideoRotation90) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
test::FunctionVideoDecoderFactory decoder_factory(
[]() { return VP9Decoder::Create(); });
CodecObserver test(5, kVideoRotation_90, absl::nullopt, "VP9",
@ -168,7 +176,9 @@ TEST_F(CodecEndToEndTest, SendsAndReceivesVP9VideoRotation90) {
TEST_F(CodecEndToEndTest, SendsAndReceivesVP9ExplicitColorSpace) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
test::FunctionVideoDecoderFactory decoder_factory(
[]() { return VP9Decoder::Create(); });
CodecObserver test(5, kVideoRotation_90,
@ -180,7 +190,9 @@ TEST_F(CodecEndToEndTest, SendsAndReceivesVP9ExplicitColorSpace) {
TEST_F(CodecEndToEndTest,
SendsAndReceivesVP9ExplicitColorSpaceWithHdrMetadata) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
test::FunctionVideoDecoderFactory decoder_factory(
[]() { return VP9Decoder::Create(); });
CodecObserver test(5, kVideoRotation_90,
@ -212,7 +224,9 @@ INSTANTIATE_TEST_SUITE_P(
TEST_P(EndToEndTestH264, SendsAndReceivesH264) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return H264Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateH264Encoder(env);
});
test::FunctionVideoDecoderFactory decoder_factory(
[]() { return H264Decoder::Create(); });
CodecObserver test(500, kVideoRotation_0, absl::nullopt, "H264",
@ -222,7 +236,9 @@ TEST_P(EndToEndTestH264, SendsAndReceivesH264) {
TEST_P(EndToEndTestH264, SendsAndReceivesH264VideoRotation90) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return H264Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateH264Encoder(env);
});
test::FunctionVideoDecoderFactory decoder_factory(
[]() { return H264Decoder::Create(); });
CodecObserver test(5, kVideoRotation_90, absl::nullopt, "H264",
@ -231,11 +247,12 @@ TEST_P(EndToEndTestH264, SendsAndReceivesH264VideoRotation90) {
}
TEST_P(EndToEndTestH264, SendsAndReceivesH264PacketizationMode0) {
cricket::VideoCodec codec =
cricket::CreateVideoCodec(cricket::kH264CodecName);
codec.SetParam(cricket::kH264FmtpPacketizationMode, "0");
SdpVideoFormat codec(cricket::kH264CodecName);
codec.parameters[cricket::kH264FmtpPacketizationMode] = "0";
test::FunctionVideoEncoderFactory encoder_factory(
[codec]() { return H264Encoder::Create(codec); });
[codec](const Environment& env, const SdpVideoFormat& format) {
return CreateH264Encoder(env, H264EncoderSettings::Parse(codec));
});
test::FunctionVideoDecoderFactory decoder_factory(
[]() { return H264Decoder::Create(); });
CodecObserver test(500, kVideoRotation_0, absl::nullopt, "H264",
@ -244,11 +261,12 @@ TEST_P(EndToEndTestH264, SendsAndReceivesH264PacketizationMode0) {
}
TEST_P(EndToEndTestH264, SendsAndReceivesH264PacketizationMode1) {
cricket::VideoCodec codec =
cricket::CreateVideoCodec(cricket::kH264CodecName);
codec.SetParam(cricket::kH264FmtpPacketizationMode, "1");
SdpVideoFormat codec(cricket::kH264CodecName);
codec.parameters[cricket::kH264FmtpPacketizationMode] = "1";
test::FunctionVideoEncoderFactory encoder_factory(
[codec]() { return H264Encoder::Create(codec); });
[codec](const Environment& env, const SdpVideoFormat& format) {
return CreateH264Encoder(env, H264EncoderSettings::Parse(codec));
});
test::FunctionVideoDecoderFactory decoder_factory(
[]() { return H264Decoder::Create(); });
CodecObserver test(500, kVideoRotation_0, absl::nullopt, "H264",

10
video/end_to_end_tests/fec_tests.cc
View File

@ -55,7 +55,10 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
public:
UlpfecRenderObserver()
: EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_([]() { return VP8Encoder::Create(); }),
encoder_factory_(
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
}),
random_(0xcafef00d1),
num_packets_sent_(0) {}
@ -372,7 +375,10 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
ulpfec_sequence_number_(0),
has_last_sequence_number_(false),
last_sequence_number_(0),
encoder_factory_([]() { return VP8Encoder::Create(); }) {}
encoder_factory_(
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
}) {}
private:
Action OnSendRtp(rtc::ArrayView<const uint8_t> packet) override {

5
video/end_to_end_tests/frame_encryption_tests.cc
View File

@ -31,7 +31,10 @@ class DecryptedFrameObserver : public test::EndToEndTest,
public:
DecryptedFrameObserver()
: EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_([] { return VP8Encoder::Create(); }) {}
encoder_factory_(
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
}) {}
private:
void ModifyVideoConfigs(

5
video/end_to_end_tests/histogram_tests.cc
View File

@ -50,7 +50,10 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
use_fec_(use_fec),
screenshare_(screenshare),
// This test uses NACK, so to send FEC we can't use a fake encoder.
encoder_factory_([]() { return VP8Encoder::Create(); }),
encoder_factory_(
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
}),
num_frames_received_(0) {}
private:

6
video/end_to_end_tests/multi_codec_receive_tests.cc
View File

@ -202,13 +202,13 @@ void MultiCodecReceiveTest::RunTestWithCodecs(
[](const Environment& env,
const SdpVideoFormat& format) -> std::unique_ptr<VideoEncoder> {
if (format.name == "VP8") {
return VP8Encoder::Create();
return CreateVp8Encoder(env);
}
if (format.name == "VP9") {
return VP9Encoder::Create();
return CreateVp9Encoder(env);
}
if (format.name == "H264") {
return H264Encoder::Create();
return CreateH264Encoder(env);
}
RTC_DCHECK_NOTREACHED() << format.name;
return nullptr;

4
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -58,7 +58,9 @@ void MultiStreamTester::RunTest() {
VideoReceiveStreamInterface* receive_streams[kNumStreams];
test::FrameGeneratorCapturer* frame_generators[kNumStreams];
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory =
CreateBuiltinVideoBitrateAllocatorFactory();
InternalDecoderFactory decoder_factory;

5
video/end_to_end_tests/retransmission_tests.cc
View File

@ -372,7 +372,10 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
enable_rtx ? test::VideoTestConstants::kSendRtxSsrcs[0]
: test::VideoTestConstants::kVideoSendSsrcs[0]),
retransmission_payload_type_(GetPayloadType(enable_rtx, enable_red)),
encoder_factory_([]() { return VP8Encoder::Create(); }),
encoder_factory_(
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
}),
marker_bits_observed_(0),
retransmitted_timestamp_(0) {}

4
video/end_to_end_tests/rtp_rtcp_tests.cc
View File

@ -467,7 +467,9 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
static constexpr int kFrameRate = 15;
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
SendTask(task_queue(), [&]() {
CreateCalls();

16
video/picture_id_tests.cc
View File

@ -363,7 +363,9 @@ void PictureIdTest::TestPictureIdIncreaseAfterRecreateStreams(
TEST_P(PictureIdTest, ContinuousAfterReconfigureVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
SetupEncoder(&encoder_factory, "VP8");
TestPictureIdContinuousAfterReconfigure({1, 3, 3, 1, 1});
}
@ -371,14 +373,18 @@ TEST_P(PictureIdTest, ContinuousAfterReconfigureVp8) {
// TODO(bugs.webrtc.org/14985): Investigate and reenable.
TEST_P(PictureIdTest, DISABLED_IncreasingAfterRecreateStreamVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
SetupEncoder(&encoder_factory, "VP8");
TestPictureIdIncreaseAfterRecreateStreams({1, 3, 3, 1, 1});
}
TEST_P(PictureIdTest, ContinuousAfterStreamCountChangeVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
// Make sure that the picture id is not reset if the stream count goes
// down and then up.
SetupEncoder(&encoder_factory, "VP8");
@ -428,7 +434,9 @@ TEST_P(PictureIdTest, ContinuousAfterStreamCountChangeSimulcastEncoderAdapter) {
// TODO(bugs.webrtc.org/14985): Investigate and reenable.
TEST_P(PictureIdTest, DISABLED_IncreasingAfterRecreateStreamVp9) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
SetupEncoder(&encoder_factory, "VP9");
TestPictureIdIncreaseAfterRecreateStreams({1, 1});
}

6
video/quality_scaling_tests.cc
View File

@ -90,11 +90,11 @@ class ScalingObserver : public test::SendTest {
[](const Environment& env,
const SdpVideoFormat& format) -> std::unique_ptr<VideoEncoder> {
if (format.name == "VP8")
return VP8Encoder::Create();
return CreateVp8Encoder(env);
if (format.name == "VP9")
return VP9Encoder::Create();
return CreateVp9Encoder(env);
if (format.name == "H264")
return H264Encoder::Create();
return CreateH264Encoder(env);
RTC_DCHECK_NOTREACHED() << format.name;
return nullptr;
}),

61
video/video_send_stream_tests.cc
View File

@ -669,14 +669,18 @@ class UlpfecObserver : public test::EndToEndTest {
TEST_F(VideoSendStreamTest, SupportsUlpfecWithExtensions) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
UlpfecObserver test(true, false, true, true, "VP8", &encoder_factory);
RunBaseTest(&test);
}
TEST_F(VideoSendStreamTest, SupportsUlpfecWithoutExtensions) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
UlpfecObserver test(false, false, true, true, "VP8", &encoder_factory);
RunBaseTest(&test);
}
@ -692,7 +696,9 @@ class VideoSendStreamWithoutUlpfecTest : public test::CallTest {
TEST_F(VideoSendStreamWithoutUlpfecTest, NoUlpfecIfDisabledThroughFieldTrial) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
UlpfecObserver test(false, false, false, false, "VP8", &encoder_factory,
kReducedTimeout);
RunBaseTest(&test);
@ -722,7 +728,9 @@ TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForH264WithoutNackEnabled) {
TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForVp8WithNackEnabled) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
UlpfecObserver test(false, true, true, true, "VP8", &encoder_factory);
RunBaseTest(&test);
}
@ -730,7 +738,9 @@ TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForVp8WithNackEnabled) {
#if defined(RTC_ENABLE_VP9)
TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForVp9WithNackEnabled) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
// Use kLongTimeout timeout because the test is flaky with kDefaultTimeout.
UlpfecObserver test(false, true, true, true, "VP9", &encoder_factory,
test::VideoTestConstants::kLongTimeout);
@ -865,28 +875,36 @@ class FlexfecObserver : public test::EndToEndTest {
TEST_F(VideoSendStreamTest, SupportsFlexfecVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
FlexfecObserver test(false, false, "VP8", &encoder_factory, 1);
RunBaseTest(&test);
}
TEST_F(VideoSendStreamTest, SupportsFlexfecSimulcastVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
FlexfecObserver test(false, false, "VP8", &encoder_factory, 2);
RunBaseTest(&test);
}
TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
FlexfecObserver test(false, true, "VP8", &encoder_factory, 1);
RunBaseTest(&test);
}
TEST_F(VideoSendStreamTest, SupportsFlexfecWithRtpExtensionsVp8) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
FlexfecObserver test(true, false, "VP8", &encoder_factory, 1);
RunBaseTest(&test);
}
@ -894,14 +912,18 @@ TEST_F(VideoSendStreamTest, SupportsFlexfecWithRtpExtensionsVp8) {
#if defined(RTC_ENABLE_VP9)
TEST_F(VideoSendStreamTest, SupportsFlexfecVp9) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
FlexfecObserver test(false, false, "VP9", &encoder_factory, 1);
RunBaseTest(&test);
}
TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackVp9) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
FlexfecObserver test(false, true, "VP9", &encoder_factory, 1);
RunBaseTest(&test);
}
@ -2992,7 +3014,10 @@ class Vp9HeaderObserver : public test::SendTest {
public:
explicit Vp9HeaderObserver(const Vp9TestParams& params)
: SendTest(test::VideoTestConstants::kLongTimeout),
encoder_factory_([]() { return VP9Encoder::Create(); }),
encoder_factory_(
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
}),
params_(params),
vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) {}
@ -4258,7 +4283,9 @@ TEST_F(VideoSendStreamTest, TestTemporalLayersVp8SimulcastWithDifferentNumTls) {
TEST_F(VideoSendStreamTest, TestTemporalLayersVp8SimulcastWithoutSimAdapter) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
TestTemporalLayers(&encoder_factory, "VP8",
/*num_temporal_layers=*/{2, 2},
@ -4308,7 +4335,9 @@ TEST_F(VideoSendStreamTest, TestScalabilityModeVp8SimulcastWithDifferentMode) {
TEST_F(VideoSendStreamTest, TestScalabilityModeVp8SimulcastWithoutSimAdapter) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp8Encoder(env);
});
TestTemporalLayers(&encoder_factory, "VP8",
/*num_temporal_layers=*/{},
@ -4317,7 +4346,9 @@ TEST_F(VideoSendStreamTest, TestScalabilityModeVp8SimulcastWithoutSimAdapter) {
TEST_F(VideoSendStreamTest, TestTemporalLayersVp9) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP9Encoder::Create(); });
[](const Environment& env, const SdpVideoFormat& format) {
return CreateVp9Encoder(env);
});
TestTemporalLayers(&encoder_factory, "VP9",
/*num_temporal_layers=*/{2},

9
video/video_stream_encoder_unittest.cc
View File

@ -8956,19 +8956,20 @@ class VideoStreamEncoderWithRealEncoderTest
void SetUp() override {
VideoStreamEncoderTest::SetUp();
Environment env = CreateEnvironment(&field_trials_);
std::unique_ptr<VideoEncoder> encoder;
switch (codec_type_) {
case kVideoCodecVP8:
encoder = VP8Encoder::Create();
encoder = CreateVp8Encoder(env);
break;
case kVideoCodecVP9:
encoder = VP9Encoder::Create();
encoder = CreateVp9Encoder(env);
break;
case kVideoCodecAV1:
encoder = CreateLibaomAv1Encoder();
encoder = CreateLibaomAv1Encoder(env);
break;
case kVideoCodecH264:
encoder = H264Encoder::Create();
encoder = CreateH264Encoder(env);
break;
case kVideoCodecH265:
// TODO(bugs.webrtc.org/13485): Use a fake encoder