| /* |
| * Copyright 2004 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "pc/codec_vendor.h" |
| |
| #include <memory> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "absl/strings/str_cat.h" |
| #include "absl/strings/string_view.h" |
| #include "api/environment/environment.h" |
| #include "api/field_trials.h" |
| #include "api/media_types.h" |
| #include "api/payload_type.h" |
| #include "api/rtc_error.h" |
| #include "api/rtp_parameters.h" |
| #include "api/rtp_transceiver_direction.h" |
| #include "api/test/rtc_error_matchers.h" |
| #include "api/video_codecs/sdp_video_format.h" |
| #include "call/fake_payload_type_suggester.h" |
| #include "media/base/codec.h" |
| #include "media/base/codec_list.h" |
| #include "media/base/fake_media_engine.h" |
| #include "media/base/media_constants.h" |
| #include "media/base/test_utils.h" |
| #include "pc/media_options.h" |
| #include "pc/rtp_parameters_conversion.h" |
| #include "pc/session_description.h" |
| #include "pc/test/full_codec_matrix.h" |
| #include "rtc_base/checks.h" |
| #include "test/create_test_environment.h" |
| #include "test/create_test_field_trials.h" |
| #include "test/gmock.h" |
| #include "test/gtest.h" |
| |
| namespace webrtc { |
| namespace { |
| |
| using ::testing::Contains; |
| using ::testing::ElementsAre; |
| using ::testing::Eq; |
| using ::testing::Field; |
| using ::testing::Ne; |
| using ::testing::Not; |
| using ::testing::Pair; |
| using ::testing::StrCaseEq; |
| |
| Codec CreateRedAudioCodec(absl::string_view encoding_id) { |
| Codec red = CreateAudioCodec(63, "red", 48000, 2); |
| red.SetParam(kCodecParamNotInNameValueFormat, |
| std::string(encoding_id) + '/' + std::string(encoding_id)); |
| return red; |
| } |
| |
| const Codec kAudioCodecs1[] = {CreateAudioCodec(111, "opus", 48000, 2), |
| CreateRedAudioCodec("111"), |
| CreateAudioCodec(102, "G722", 16000, 1), |
| CreateAudioCodec(0, "PCMU", 8000, 1), |
| CreateAudioCodec(8, "PCMA", 8000, 1), |
| CreateAudioCodec(107, "CN", 48000, 1)}; |
| |
| const Codec kAudioCodecs2[] = { |
| CreateAudioCodec(126, "foo", 16000, 1), |
| CreateAudioCodec(0, "PCMU", 8000, 1), |
| CreateAudioCodec(127, "G722", 16000, 1), |
| }; |
| |
| const Codec kAudioCodecsAnswer[] = { |
| CreateAudioCodec(102, "G722", 16000, 1), |
| CreateAudioCodec(0, "PCMU", 8000, 1), |
| }; |
| |
| // Occupies the dynamic payload type space except for the `free_payload_types` |
| // lowest payload types. A peer that supports many codecs has no payload types |
| // to spare for codecs that it does not put in the offer or answer, so tests |
| // that leave room for the expected codecs only fail if a codec that should be |
| // excluded is assigned a payload type. |
| void OccupyDynamicPayloadTypes(FakePayloadTypeSuggester& pt_suggester, |
| MediaType media_type, |
| int free_payload_types) { |
| int filler = 0; |
| int left_free = 0; |
| for (auto [first, last] : {std::pair{35, 63}, std::pair{96, 127}}) { |
| for (int pt = first; pt <= last; ++pt) { |
| if (left_free < free_payload_types) { |
| ++left_free; |
| continue; |
| } |
| std::string name = absl::StrCat("filler", filler++); |
| pt_suggester.AddLocalMapping("filler", PayloadType(pt), |
| media_type == MediaType::AUDIO |
| ? CreateAudioCodec(pt, name, 16000, 1) |
| : CreateVideoCodec(pt, name)); |
| } |
| } |
| } |
| |
| // Occupies the payload types in [`first`, `last`] with codecs that the media |
| // engine does not know about, as an endpoint whose peer has munged codecs of |
| // its own into the session description would have done. |
| void OccupyPayloadTypeRange(FakePayloadTypeSuggester& pt_suggester, |
| MediaType media_type, |
| int first, |
| int last) { |
| for (int pt = first; pt <= last; ++pt) { |
| std::string name = absl::StrCat("filler", pt); |
| pt_suggester.AddLocalMapping("filler", PayloadType(pt), |
| media_type == MediaType::AUDIO |
| ? CreateAudioCodec(pt, name, 16000, 1) |
| : CreateVideoCodec(pt, name)); |
| } |
| } |
| |
| TEST(CodecVendorTest, TestSetAudioCodecs) { |
| FieldTrials trials = |
| CreateTestFieldTrials("WebRTC-PayloadTypesInTransport/Disabled/"); |
| std::vector<Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1); |
| std::vector<Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2); |
| |
| // The merged list of codecs should contain any send codecs that are also |
| // nominally in the receive codecs list. Payload types should be picked from |
| // the send codecs and a number-of-channels of 0 and 1 should be equivalent |
| // (set to 1). This equals what happens when the send codecs are used in an |
| // offer and the receive codecs are used in the following answer. |
| const std::vector<Codec> sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer); |
| RTC_CHECK_EQ(send_codecs[2].name, "G722") |
| << "Please don't change shared test data!"; |
| RTC_CHECK_EQ(recv_codecs[2].name, "G722") |
| << "Please don't change shared test data!"; |
| // Alter iLBC send codec to have zero channels, to test that that is handled |
| // properly. |
| send_codecs[2].channels = 0; |
| |
| // Alter PCMU receive codec to be lowercase, to test that case conversions |
| // are handled properly. |
| recv_codecs[1].name = "pcmu"; |
| |
| // Test proper merge |
| FakeMediaEngine media_engine; |
| media_engine.SetAudioSendCodecs(send_codecs); |
| media_engine.SetAudioRecvCodecs(recv_codecs); |
| { |
| CodecVendor codec_vendor(&media_engine, false, trials); |
| EXPECT_EQ(send_codecs, codec_vendor.audio_send_codecs().codecs()); |
| EXPECT_EQ(recv_codecs, codec_vendor.audio_recv_codecs().codecs()); |
| EXPECT_EQ(sendrecv_codecs, codec_vendor.audio_sendrecv_codecs().codecs()); |
| } |
| |
| // Test empty send codecs list |
| CodecList no_codecs; |
| media_engine.SetAudioSendCodecs(no_codecs.codecs()); |
| media_engine.SetAudioRecvCodecs(recv_codecs); |
| { |
| CodecVendor codec_vendor(&media_engine, false, trials); |
| EXPECT_EQ(no_codecs.codecs(), codec_vendor.audio_send_codecs().codecs()); |
| EXPECT_EQ(recv_codecs, codec_vendor.audio_recv_codecs().codecs()); |
| EXPECT_EQ(no_codecs.codecs(), |
| codec_vendor.audio_sendrecv_codecs().codecs()); |
| } |
| |
| // Test empty recv codecs list |
| media_engine.SetAudioSendCodecs(send_codecs); |
| media_engine.SetAudioRecvCodecs(no_codecs.codecs()); |
| { |
| CodecVendor codec_vendor(&media_engine, false, trials); |
| EXPECT_EQ(send_codecs, codec_vendor.audio_send_codecs().codecs()); |
| EXPECT_EQ(no_codecs.codecs(), codec_vendor.audio_recv_codecs().codecs()); |
| EXPECT_EQ(no_codecs.codecs(), |
| codec_vendor.audio_sendrecv_codecs().codecs()); |
| } |
| |
| // Test all empty codec lists |
| media_engine.SetAudioSendCodecs(no_codecs.codecs()); |
| media_engine.SetAudioRecvCodecs(no_codecs.codecs()); |
| { |
| CodecVendor codec_vendor(&media_engine, false, trials); |
| EXPECT_EQ(no_codecs.codecs(), codec_vendor.audio_send_codecs().codecs()); |
| EXPECT_EQ(no_codecs.codecs(), codec_vendor.audio_recv_codecs().codecs()); |
| EXPECT_EQ(no_codecs.codecs(), |
| codec_vendor.audio_sendrecv_codecs().codecs()); |
| } |
| } |
| |
| TEST(CodecVendorTest, VideoRtxIsIncludedWhenAskedFor) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| std::vector<Codec> video_codecs({ |
| CreateVideoCodec(97, "vp8"), |
| CreateVideoRtxCodec(98, 97), |
| }); |
| media_engine.SetVideoSendCodecs(video_codecs); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ true, |
| env.field_trials()); |
| FakePayloadTypeSuggester pt_suggester; |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer( |
| MediaDescriptionOptions(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false), |
| MediaSessionOptions(), nullptr, pt_suggester); |
| EXPECT_THAT(offered_codecs.value(), |
| Contains(Field("name", &Codec::name, "rtx"))); |
| } |
| |
| TEST(CodecVendorTest, VideoRtxIsExcludedWhenNotAskedFor) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| std::vector<Codec> video_codecs({ |
| CreateVideoCodec(97, "vp8"), |
| CreateVideoRtxCodec(98, 97), |
| }); |
| media_engine.SetVideoSendCodecs(video_codecs); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| FakePayloadTypeSuggester pt_suggester; |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer( |
| MediaDescriptionOptions(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false), |
| MediaSessionOptions(), nullptr, pt_suggester); |
| EXPECT_THAT(offered_codecs.value(), |
| Not(Contains(Field("name", &Codec::name, "rtx")))); |
| } |
| |
| TEST(CodecVendorTest, PreferencesAffectCodecChoice) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| std::vector<Codec> video_codecs({ |
| CreateVideoCodec(97, "vp8"), |
| CreateVideoRtxCodec(98, 97), |
| CreateVideoCodec(99, "vp9"), |
| CreateVideoRtxCodec(100, 99), |
| }); |
| media_engine.SetVideoSendCodecs(video_codecs); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false); |
| options.codec_preferences = { |
| ToRtpCodecCapability(CreateVideoCodec(PayloadType::NotSet(), "vp9")), |
| }; |
| FakePayloadTypeSuggester pt_suggester; |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer(options, MediaSessionOptions(), |
| nullptr, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()); |
| EXPECT_THAT(offered_codecs.value(), |
| Contains(Field("name", &Codec::name, "vp9"))); |
| EXPECT_THAT(offered_codecs.value(), |
| Not(Contains(Field("name", &Codec::name, "vp8")))); |
| EXPECT_THAT(offered_codecs.value().size(), Eq(1)); |
| } |
| |
| // Regression test for a crash in re-offers: the codecs of the previous local |
| // description used to be added to the offer with the payload types they had |
| // then, while the remaining codecs were added with the payload types of the |
| // newly merged codec list. If a payload type had been reassigned to another |
| // codec in between, the two disagreed and the offer ended up with one payload |
| // type used by two codecs. |
| TEST(CodecVendorTest, ReOfferUsesPayloadTypesOfMergedCodecList) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| std::vector<Codec> video_codecs({ |
| CreateVideoCodec(97, "vp8"), |
| CreateVideoCodec(99, "vp9"), |
| }); |
| media_engine.SetVideoSendCodecs(video_codecs); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false); |
| FakePayloadTypeSuggester pt_suggester; |
| // Record mappings where vp8 has moved to payload type 120, and the payload |
| // type it used to have (97) now belongs to vp9. |
| ASSERT_TRUE( |
| pt_suggester.AddLocalMapping("mid", 120, CreateVideoCodec(120, "vp8")) |
| .ok()); |
| ASSERT_TRUE( |
| pt_suggester.AddLocalMapping("mid", 97, CreateVideoCodec(97, "vp9")) |
| .ok()); |
| |
| // The previous local description still has vp8 on payload type 97. |
| auto video_description = std::make_unique<VideoContentDescription>(); |
| video_description->set_codecs({CreateVideoCodec(97, "vp8")}); |
| ContentInfo current_content(MediaProtocolType::kRtp, "mid", |
| std::move(video_description)); |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer(options, MediaSessionOptions(), |
| ¤t_content, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()); |
| // Both codecs are offered, each with the payload type of the merged codec |
| // list, so no payload type is used twice. |
| EXPECT_THAT(offered_codecs.value(), |
| ElementsAre(AllOf(Field("name", &Codec::name, "vp8"), |
| Field("id", &Codec::id, 120)), |
| AllOf(Field("name", &Codec::name, "vp9"), |
| Field("id", &Codec::id, 97)))); |
| } |
| |
| TEST(CodecVendorTest, GetNegotiatedCodecsForAnswerSimple) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| std::vector<Codec> video_codecs({ |
| CreateVideoCodec(97, "vp8"), |
| CreateVideoRtxCodec(98, 97), |
| CreateVideoCodec(99, "vp9"), |
| CreateVideoRtxCodec(100, 99), |
| }); |
| media_engine.SetVideoSendCodecs(video_codecs); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ true, |
| env.field_trials()); |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false); |
| FakePayloadTypeSuggester pt_suggester; |
| ContentInfo* current_content = nullptr; |
| RTCErrorOr<std::vector<Codec>> answered_codecs = |
| codec_vendor.GetNegotiatedCodecsForAnswer( |
| options, MediaSessionOptions(), RtpTransceiverDirection::kSendOnly, |
| RtpTransceiverDirection::kSendOnly, current_content, video_codecs, |
| pt_suggester); |
| EXPECT_THAT(answered_codecs, IsRtcOkAndHolds(video_codecs)); |
| } |
| |
| TEST(CodecVendorTest, GetNegotiatedCodecsForAnswerWithCollision) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| std::vector<Codec> video_codecs({ |
| CreateVideoCodec(97, "vp8"), |
| CreateVideoCodec(99, "vp9"), |
| CreateVideoCodec(101, "av1"), |
| }); |
| std::vector<Codec> remote_codecs({ |
| CreateVideoCodec(97, "av1"), |
| CreateVideoCodec(99, "vp9"), |
| }); |
| media_engine.SetVideoSendCodecs(video_codecs); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false); |
| FakePayloadTypeSuggester pt_suggester; |
| ContentInfo* current_content = nullptr; |
| RTCErrorOr<std::vector<Codec>> answered_codecs = |
| codec_vendor.GetNegotiatedCodecsForAnswer( |
| options, MediaSessionOptions(), RtpTransceiverDirection::kSendOnly, |
| RtpTransceiverDirection::kSendOnly, current_content, remote_codecs, |
| pt_suggester); |
| EXPECT_THAT(answered_codecs, IsRtcOkAndHolds(remote_codecs)); |
| } |
| |
| TEST(CodecVendorMergeTest, BasicTestSetup) { |
| if (CreateTestFieldTrials().IsEnabled("WebRTC-PayloadTypesInTransport")) { |
| GTEST_SKIP(); |
| } |
| CodecList reference_codecs; |
| const std::string mid = "mid"; |
| CodecList merged_codecs; |
| FakePayloadTypeSuggester pt_suggester; |
| RTCError error = |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester); |
| EXPECT_TRUE(error.ok()); |
| } |
| |
| TEST(CodecVendorMergeTest, IdenticalListsMergeWithNoChange) { |
| if (CreateTestFieldTrials().IsEnabled("WebRTC-PayloadTypesInTransport")) { |
| GTEST_SKIP(); |
| } |
| CodecList reference_codecs; |
| const std::string mid = "mid"; |
| CodecList merged_codecs; |
| FakePayloadTypeSuggester pt_suggester; |
| Codec some_codec = CreateVideoCodec(97, "foo"); |
| RTCErrorOr<PayloadType> pt_or_error = |
| pt_suggester.SuggestPayloadType(mid, some_codec, false); |
| ASSERT_THAT(pt_or_error.value(), Eq(97)); |
| reference_codecs.push_back(some_codec); |
| merged_codecs.push_back(some_codec); |
| RTCError error = |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester); |
| EXPECT_TRUE(error.ok()); |
| EXPECT_THAT(merged_codecs.size(), Eq(1)); |
| EXPECT_THAT(merged_codecs[0].id, Eq(97)); |
| } |
| |
| TEST(CodecVendorMergeTest, MergeRenumbersAdditionalCodecs) { |
| if (CreateTestFieldTrials().IsEnabled("WebRTC-PayloadTypesInTransport")) { |
| GTEST_SKIP(); |
| } |
| CodecList reference_codecs; |
| const std::string mid = "mid"; |
| CodecList merged_codecs; |
| FakePayloadTypeSuggester pt_suggester; |
| Codec some_codec = CreateVideoCodec(97, "foo"); |
| RTCErrorOr<PayloadType> pt_or_error = |
| pt_suggester.SuggestPayloadType(mid, some_codec, false); |
| ASSERT_THAT(pt_or_error.value(), Eq(97)); |
| merged_codecs.push_back(some_codec); |
| // Use the same PT for a reference codec. This should be renumbered. |
| Codec some_other_codec = CreateVideoCodec(97, "bar"); |
| reference_codecs.push_back(some_other_codec); |
| RTCError error = |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester); |
| EXPECT_TRUE(error.ok()); |
| EXPECT_THAT(merged_codecs.size(), Eq(2)); |
| // Both foo and bar should be present |
| EXPECT_THAT(merged_codecs.codecs(), |
| UnorderedElementsAre(Field("name", &Codec::name, "foo"), |
| Field("name", &Codec::name, "bar"))); |
| // Foo should retain 97 |
| EXPECT_THAT(merged_codecs.codecs(), |
| Contains(AllOf(Field("name", &Codec::name, "foo"), |
| Field("id", &Codec::id, 97)))); |
| // Bar should not have 97 |
| EXPECT_THAT(merged_codecs.codecs(), |
| Contains(AllOf(Field("name", &Codec::name, "bar"), |
| Field("id", &Codec::id, Ne(97))))); |
| } |
| |
| TEST(CodecVendorMergeTest, MergeRenumbersRedCodecArgument) { |
| if (CreateTestFieldTrials().IsEnabled("WebRTC-PayloadTypesInTransport")) { |
| GTEST_SKIP(); |
| } |
| CodecList reference_codecs; |
| const std::string mid = "mid"; |
| CodecList merged_codecs; |
| FakePayloadTypeSuggester pt_suggester; |
| Codec some_codec = CreateAudioCodec(100, "foo", 8000, 1); |
| merged_codecs.push_back(some_codec); |
| // Push into "reference" with a different ID |
| some_codec.id = 102; |
| reference_codecs.push_back(some_codec); |
| Codec red_codec = CreateAudioCodec(101, "red", 8000, 1); |
| ASSERT_EQ(red_codec.GetResiliencyType(), Codec::ResiliencyType::kRed); |
| red_codec.SetParam(kCodecParamNotInNameValueFormat, "102/102"); |
| reference_codecs.push_back(red_codec); |
| // Merging should add the RED codec with parameter 100/100 |
| RTCError error = |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester); |
| EXPECT_TRUE(error.ok()); |
| EXPECT_THAT(merged_codecs.size(), Eq(2)); |
| EXPECT_THAT( |
| merged_codecs.codecs(), |
| Contains(AllOf(Field("name", &Codec::name, "red"), |
| Field("params", &Codec::params, |
| ElementsAre(Pair(kCodecParamNotInNameValueFormat, |
| "100/100")))))); |
| } |
| |
| TEST(CodecVendorMergeTest, MergeRenumbersRedCodecArgumentAndMerges) { |
| if (CreateTestFieldTrials().IsEnabled("WebRTC-PayloadTypesInTransport")) { |
| GTEST_SKIP(); |
| } |
| CodecList reference_codecs; |
| const std::string mid = "mid"; |
| CodecList merged_codecs; |
| FakePayloadTypeSuggester pt_suggester; |
| Codec some_codec = CreateAudioCodec(100, "foo", 8000, 1); |
| merged_codecs.push_back(some_codec); |
| // Push into "reference" with a different ID |
| some_codec.id = 102; |
| reference_codecs.push_back(some_codec); |
| Codec red_codec = CreateAudioCodec(101, "red", 8000, 1); |
| ASSERT_EQ(red_codec.GetResiliencyType(), Codec::ResiliencyType::kRed); |
| red_codec.SetParam(kCodecParamNotInNameValueFormat, "102/102"); |
| reference_codecs.push_back(red_codec); |
| // Push the same red codec into `merged_codecs` with the 100 id |
| red_codec.SetParam(kCodecParamNotInNameValueFormat, "100/100"); |
| merged_codecs.push_back(red_codec); |
| // Merging should note the duplication and not add another codec. |
| RTCError error = |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester); |
| EXPECT_TRUE(error.ok()); |
| EXPECT_THAT(merged_codecs.size(), Eq(2)); |
| EXPECT_THAT( |
| merged_codecs.codecs(), |
| Contains(AllOf(Field("name", &Codec::name, "red"), |
| Field("params", &Codec::params, |
| ElementsAre(Pair(kCodecParamNotInNameValueFormat, |
| "100/100")))))); |
| } |
| |
| TEST(CodecVendorMergeTest, MergeWithBrokenReferenceRedErrors) { |
| if (CreateTestFieldTrials().IsEnabled("WebRTC-PayloadTypesInTransport")) { |
| GTEST_SKIP(); |
| } |
| CodecList reference_codecs; |
| const std::string mid = "mid"; |
| CodecList merged_codecs; |
| FakePayloadTypeSuggester pt_suggester; |
| Codec some_codec = CreateAudioCodec(100, "foo", 8000, 1); |
| Codec red_codec = CreateAudioCodec(101, "red", 8000, 1); |
| // Adds a RED codec that refers to codec 102, which does not exist. |
| red_codec.SetParam(kCodecParamNotInNameValueFormat, "100/102"); |
| reference_codecs.push_back(some_codec); |
| reference_codecs.push_back(red_codec); |
| // The bogus RED codec should result in an error return. |
| RTCError error = |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester); |
| EXPECT_FALSE(error.ok()); |
| EXPECT_THAT(error.type(), Eq(RTCErrorType::INTERNAL_ERROR)); |
| } |
| |
| TEST(CodecVendorMergeTest, MergeWithCollisionPicksFromTop) { |
| if (CreateTestFieldTrials().IsEnabled("WebRTC-PayloadTypesInTransport")) { |
| GTEST_SKIP(); |
| } |
| CodecList reference_codecs; |
| const std::string mid = "mid"; |
| CodecList merged_codecs; |
| FakePayloadTypeSuggester pt_suggester; |
| // Existing codec with PT 97 |
| Codec some_codec = CreateVideoCodec(97, "foo"); |
| merged_codecs.push_back(some_codec); |
| RTC_CHECK(pt_suggester.AddLocalMapping(mid, 97, some_codec).ok()); |
| |
| // New codec in reference that also wants PT 97 |
| Codec some_other_codec = CreateVideoCodec(97, "bar"); |
| reference_codecs.push_back(some_other_codec); |
| |
| // When merging with pick_from_top_of_range = true, it should pick 127 |
| RTCError error = |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester, |
| /*pick_from_top_of_range=*/true); |
| EXPECT_TRUE(error.ok()); |
| EXPECT_THAT(merged_codecs.size(), Eq(2)); |
| EXPECT_THAT(merged_codecs.codecs(), |
| Contains(AllOf(Field("name", &Codec::name, "bar"), |
| Field("id", &Codec::id, 127)))); |
| } |
| |
| #if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
| // A payload type conflict while merging means that codecs from different |
| // payload type mappings have been combined, which is an internal error rather |
| // than something an application can cause. It is fatal in debug builds; in |
| // release builds the conflicting codec is left out of the list. |
| TEST(CodecVendorMergeDeathTest, MergeAssertsOnPayloadTypeConflict) { |
| if (CreateTestFieldTrials().IsEnabled("WebRTC-PayloadTypesInTransport")) { |
| GTEST_SKIP(); |
| } |
| CodecList reference_codecs; |
| const std::string mid = "mid"; |
| CodecList merged_codecs; |
| FakePayloadTypeSuggester pt_suggester; |
| // Existing codec with PT 97. |
| Codec some_codec = CreateVideoCodec(97, "foo"); |
| merged_codecs.push_back(some_codec); |
| RTC_CHECK(pt_suggester.AddLocalMapping(mid, 97, some_codec).ok()); |
| |
| // Force the suggester to hand out the payload type of "foo" for "bar", so |
| // that the merge ends up with two codecs claiming the same payload type. |
| pt_suggester.SetSuggestion(mid, "bar", PayloadType(97)); |
| reference_codecs.push_back(CreateVideoCodec(97, "bar")); |
| |
| #if RTC_DCHECK_IS_ON |
| EXPECT_DEATH( |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester) |
| .ok(), |
| "codec_vendor.cc"); |
| #else |
| RTCError error = |
| MergeCodecsForTesting(reference_codecs, mid, merged_codecs, pt_suggester); |
| EXPECT_TRUE(error.ok()); |
| // "bar" was not added to the list. |
| EXPECT_THAT(merged_codecs.size(), Eq(1)); |
| #endif |
| } |
| #endif |
| |
| TEST(CodecVendorTest, ModifyVideoCodecsReplacesCodec) { |
| FieldTrials trials = |
| CreateTestFieldTrials("WebRTC-PayloadTypesInTransport/Disabled/"); |
| FakeMediaEngine media_engine; |
| std::vector<Codec> video_codecs({ |
| CreateVideoCodec(97, "vp8"), |
| CreateVideoCodec(99, "vp9"), |
| }); |
| media_engine.SetVideoSendCodecs(video_codecs); |
| media_engine.SetVideoRecvCodecs(video_codecs); |
| |
| CodecVendor codec_vendor(&media_engine, false, trials); |
| |
| Codec original_codec = video_codecs[0]; |
| Codec modified_codec = original_codec; |
| modified_codec.name = "modified_name"; |
| |
| Codec second_codec = video_codecs[1]; |
| |
| std::vector<std::pair<Codec, Codec>> changes; |
| changes.push_back({original_codec, modified_codec}); |
| |
| codec_vendor.ModifyVideoCodecs(changes); |
| |
| const CodecList& new_send_codecs = codec_vendor.video_send_codecs(); |
| EXPECT_THAT(new_send_codecs.codecs(), Contains(modified_codec)); |
| EXPECT_THAT(new_send_codecs.codecs(), Not(Contains(original_codec))); |
| |
| // Check that the second codec is NOT changed. |
| EXPECT_THAT(new_send_codecs.codecs(), Contains(second_codec)); |
| } |
| |
| // Once every dynamic payload type is taken, offer creation must report the |
| // exhaustion to the caller. Silently omitting the codecs that could not be |
| // assigned a payload type produces an offer that mixes two payload type |
| // mappings, which is how a BUNDLE group ends up using one payload type for two |
| // different codecs. |
| TEST(CodecVendorTest, OfferFailsWhenPayloadTypeSpaceIsExhausted) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| media_engine.SetVideoSendCodecs({CreateVideoCodec(97, "vp8")}); |
| media_engine.SetVideoRecvCodecs({CreateVideoCodec(97, "vp8")}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| |
| // Occupy the whole dynamic payload type space with codecs that the media |
| // engine does not offer, so that no payload type is left for "vp8". |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::VIDEO, |
| /*free_payload_types=*/0); |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer( |
| MediaDescriptionOptions(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false), |
| MediaSessionOptions(), nullptr, pt_suggester); |
| EXPECT_THAT(offered_codecs.error(), |
| IsRtcErrorWithType(RTCErrorType::RESOURCE_EXHAUSTED)); |
| } |
| |
| // Codecs that the direction of the media section rules out never reach the |
| // offer, so they must not be assigned a payload type either. A peer that |
| // supports many codecs has no payload types to spare for codecs it does not |
| // offer. |
| TEST(CodecVendorTest, OfferDoesNotAssignPayloadTypesToUnofferedCodecs) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| media_engine.SetVideoSendCodecs({CreateVideoCodec(96, "vp8")}); |
| // A send only media section cannot offer the receive-only codecs. |
| media_engine.SetVideoRecvCodecs({CreateVideoCodec(96, "vp8"), |
| CreateVideoCodec(97, "vp9"), |
| CreateVideoCodec(98, "av1")}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| |
| // Occupy the dynamic payload type space except for a single payload type, |
| // which leaves room for the one codec that the offer can contain. |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::VIDEO, |
| /*free_payload_types=*/1); |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer( |
| MediaDescriptionOptions(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false), |
| MediaSessionOptions(), nullptr, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()) << offered_codecs.error().message(); |
| EXPECT_THAT(offered_codecs.value(), |
| ElementsAre(Field(&Codec::name, Eq("vp8")))); |
| } |
| |
| // Runs a test both with the legacy payload type assignment and with the |
| // redesigned one that the WebRTC-PayloadTypesInTransport field trial enables. |
| class CodecVendorPayloadTypeTest : public ::testing::TestWithParam<bool> { |
| protected: |
| bool payload_types_in_transport() const { return GetParam(); } |
| |
| const Environment env_ = CreateTestEnvironment( |
| {.field_trials = absl::string_view( |
| GetParam() ? "WebRTC-PayloadTypesInTransport/Enabled/" |
| : "WebRTC-PayloadTypesInTransport/Disabled/")}); |
| }; |
| |
| // Codecs excluded by transceiver codec preferences must not be assigned a |
| // payload type when creating an offer. |
| TEST_P(CodecVendorPayloadTypeTest, |
| OfferDoesNotAssignPayloadTypesToExcludedCodecs) { |
| FakeMediaEngine media_engine; |
| // "av1" comes last, so it only gets a payload type if the codecs that the |
| // codec preferences exclude do not take it first. |
| media_engine.SetVideoCodecs({CreateVideoCodec(96, "vp8"), |
| CreateVideoCodec(97, "vp9"), |
| CreateVideoCodec(98, "av1")}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env_.field_trials()); |
| |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::VIDEO, |
| /*free_payload_types=*/1); |
| |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendRecv, false); |
| RtpCodecCapability pref; |
| pref.name = "av1"; |
| pref.kind = MediaType::VIDEO; |
| pref.clock_rate = 90000; |
| options.codec_preferences = {pref}; |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer(options, MediaSessionOptions(), |
| nullptr, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()) << offered_codecs.error().message(); |
| EXPECT_THAT(offered_codecs.value(), |
| ElementsAre(Field(&Codec::name, Eq("av1")))); |
| } |
| |
| // RED codecs whose primary codecs are excluded by transceiver codec |
| // preferences must not be assigned a payload type when creating an offer. |
| TEST(CodecVendorTest, OfferDoesNotAssignPayloadTypesToDanglingRedCodecs) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| media_engine.SetAudioCodecs({CreateAudioCodec(111, "opus", 48000, 2), |
| CreateRedAudioCodec("111"), |
| CreateAudioCodec(102, "G722", 16000, 1)}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::AUDIO, |
| /*free_payload_types=*/1); |
| |
| MediaDescriptionOptions options(MediaType::AUDIO, "mid", |
| RtpTransceiverDirection::kSendRecv, false); |
| RtpCodecCapability red_pref; |
| red_pref.name = "red"; |
| red_pref.kind = MediaType::AUDIO; |
| red_pref.clock_rate = 48000; |
| red_pref.num_channels = 2; |
| RtpCodecCapability g722_pref; |
| g722_pref.name = "G722"; |
| g722_pref.kind = MediaType::AUDIO; |
| g722_pref.clock_rate = 16000; |
| g722_pref.num_channels = 1; |
| options.codec_preferences = {red_pref, g722_pref}; |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer(options, MediaSessionOptions(), |
| nullptr, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()) << offered_codecs.error().message(); |
| EXPECT_THAT(offered_codecs.value(), |
| ElementsAre(Field(&Codec::name, Eq("G722")))); |
| } |
| |
| // Codecs excluded by `codecs_to_include` must not be assigned a payload type |
| // when creating an offer. |
| TEST(CodecVendorTest, OfferRespectsCodecsToInclude) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| media_engine.SetVideoCodecs({CreateVideoCodec(96, "vp8"), |
| CreateVideoCodec(97, "vp9"), |
| CreateVideoCodec(98, "av1")}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::VIDEO, |
| /*free_payload_types=*/1); |
| |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendRecv, false); |
| options.codecs_to_include = {CreateVideoCodec(96, "vp8")}; |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer(options, MediaSessionOptions(), |
| nullptr, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()) << offered_codecs.error().message(); |
| EXPECT_THAT(offered_codecs.value(), |
| ElementsAre(Field(&Codec::name, Eq("vp8")))); |
| } |
| |
| // When WebRTC-PayloadTypesInTransport is enabled, unoffered codecs must not be |
| // assigned a payload type when creating an offer. |
| TEST(CodecVendorTest, OfferRespectsDirectionWithPayloadTypesInTransport) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Enabled/"}); |
| FakeMediaEngine media_engine; |
| media_engine.SetVideoSendCodecs({CreateVideoCodec(96, "vp8")}); |
| media_engine.SetVideoRecvCodecs({CreateVideoCodec(96, "vp8"), |
| CreateVideoCodec(97, "vp9"), |
| CreateVideoCodec(98, "av1")}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::VIDEO, |
| /*free_payload_types=*/1); |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer( |
| MediaDescriptionOptions(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendOnly, false), |
| MediaSessionOptions(), nullptr, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()) << offered_codecs.error().message(); |
| EXPECT_THAT(offered_codecs.value(), |
| ElementsAre(Field(&Codec::name, Eq("vp8")))); |
| } |
| |
| // Comfort noise codecs must not be assigned a payload type when the |
| // application does not want them in the offer. |
| TEST_P(CodecVendorPayloadTypeTest, |
| OfferDoesNotAssignPayloadTypesToComfortNoise) { |
| FakeMediaEngine media_engine; |
| // "CN" comes first, so it takes a payload type that is needed by the codecs |
| // that follow it unless it is excluded from the offer. |
| media_engine.SetAudioCodecs({CreateAudioCodec(107, "CN", 48000, 1), |
| CreateAudioCodec(111, "opus", 48000, 2)}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env_.field_trials()); |
| |
| // Leave room for exactly the codecs that the offer is expected to contain: |
| // "opus", plus the "red" and "telephone-event" codecs that accompany it in |
| // the redesigned payload type assignment. |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes( |
| pt_suggester, MediaType::AUDIO, |
| /*free_payload_types=*/payload_types_in_transport() ? 3 : 1); |
| |
| MediaSessionOptions session_options; |
| session_options.vad_enabled = false; |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer( |
| MediaDescriptionOptions(MediaType::AUDIO, "mid", |
| RtpTransceiverDirection::kSendRecv, false), |
| session_options, nullptr, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()) << offered_codecs.error().message(); |
| EXPECT_THAT(offered_codecs.value(), |
| Not(Contains(Field(&Codec::name, StrCaseEq("CN"))))); |
| EXPECT_THAT(offered_codecs.value(), |
| Contains(Field(&Codec::name, Eq("opus")))); |
| } |
| |
| // Codecs excluded by transceiver codec preferences must not be assigned a |
| // payload type when creating an answer. |
| TEST_P(CodecVendorPayloadTypeTest, |
| AnswerDoesNotAssignPayloadTypesToExcludedCodecs) { |
| FakeMediaEngine media_engine; |
| // "av1" comes last, so it only gets a payload type if the codecs that the |
| // codec preferences exclude do not take it first. |
| media_engine.SetVideoCodecs({CreateVideoCodec(96, "vp8"), |
| CreateVideoCodec(97, "vp9"), |
| CreateVideoCodec(98, "av1")}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env_.field_trials()); |
| |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::VIDEO, |
| /*free_payload_types=*/1); |
| |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendRecv, false); |
| RtpCodecCapability pref; |
| pref.name = "av1"; |
| pref.kind = MediaType::VIDEO; |
| pref.clock_rate = 90000; |
| options.codec_preferences = {pref}; |
| |
| std::vector<Codec> codecs_from_offer = {CreateVideoCodec(96, "vp8"), |
| CreateVideoCodec(98, "av1")}; |
| RTCErrorOr<std::vector<Codec>> answered_codecs = |
| codec_vendor.GetNegotiatedCodecsForAnswer( |
| options, MediaSessionOptions(), RtpTransceiverDirection::kSendRecv, |
| RtpTransceiverDirection::kSendRecv, /*current_content=*/nullptr, |
| codecs_from_offer, pt_suggester); |
| ASSERT_TRUE(answered_codecs.ok()) << answered_codecs.error().message(); |
| EXPECT_THAT(answered_codecs.value(), |
| ElementsAre(Field(&Codec::name, Eq("av1")))); |
| } |
| |
| // Comfort noise codecs must not be assigned a payload type when the |
| // application does not want them in the answer. |
| TEST(CodecVendorTest, AnswerDoesNotAssignPayloadTypesToComfortNoise) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Disabled/"}); |
| FakeMediaEngine media_engine; |
| // "CN" comes first, so it takes the last free payload type unless it is |
| // excluded from the answer. |
| media_engine.SetAudioCodecs({CreateAudioCodec(107, "CN", 48000, 1), |
| CreateAudioCodec(111, "opus", 48000, 2)}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::AUDIO, |
| /*free_payload_types=*/1); |
| |
| MediaSessionOptions session_options; |
| session_options.vad_enabled = false; |
| std::vector<Codec> codecs_from_offer = { |
| CreateAudioCodec(111, "opus", 48000, 2)}; |
| RTCErrorOr<std::vector<Codec>> answered_codecs = |
| codec_vendor.GetNegotiatedCodecsForAnswer( |
| MediaDescriptionOptions(MediaType::AUDIO, "mid", |
| RtpTransceiverDirection::kSendRecv, false), |
| session_options, RtpTransceiverDirection::kSendRecv, |
| RtpTransceiverDirection::kSendRecv, /*current_content=*/nullptr, |
| codecs_from_offer, pt_suggester); |
| ASSERT_TRUE(answered_codecs.ok()) << answered_codecs.error().message(); |
| EXPECT_THAT(answered_codecs.value(), |
| ElementsAre(Field(&Codec::name, Eq("opus")))); |
| } |
| |
| // The forward error correction mechanisms that the transceiver codec |
| // preferences do not include must not be assigned a payload type. |
| TEST(CodecVendorWithPayloadTypesInTransportTest, |
| OfferDoesNotAssignPayloadTypesToExcludedFecCodecs) { |
| Environment env = CreateTestEnvironment( |
| {.field_trials = "WebRTC-PayloadTypesInTransport/Enabled/"}); |
| FakeMediaEngine media_engine; |
| // The FEC codecs make the codec configuration of "vp8" carry ULPFEC and |
| // FlexFEC, neither of which the codec preferences below ask for. |
| media_engine.SetVideoCodecs({CreateVideoCodec(96, "vp8"), |
| CreateVideoCodec(97, kUlpfecCodecName), |
| CreateVideoCodec(98, kFlexfecCodecName)}); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ false, |
| env.field_trials()); |
| |
| // Leave room for "vp8" only, so that the offer can only be created if the |
| // FEC codecs are left without a payload type. |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyDynamicPayloadTypes(pt_suggester, MediaType::VIDEO, |
| /*free_payload_types=*/1); |
| |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendRecv, false); |
| RtpCodecCapability pref; |
| pref.name = "vp8"; |
| pref.kind = MediaType::VIDEO; |
| pref.clock_rate = 90000; |
| options.codec_preferences = {pref}; |
| |
| RTCErrorOr<std::vector<Codec>> offered_codecs = |
| codec_vendor.GetNegotiatedCodecsForOffer(options, MediaSessionOptions(), |
| nullptr, pt_suggester); |
| ASSERT_TRUE(offered_codecs.ok()) << offered_codecs.error().message(); |
| EXPECT_THAT(offered_codecs.value(), |
| ElementsAre(Field(&Codec::name, Eq("vp8")))); |
| } |
| |
| // Builds the transceiver codec preferences of an application that wants VP8 |
| // and AV1 only, with retransmission for both. |
| std::vector<RtpCodecCapability> Vp8AndAv1Preferences() { |
| const std::vector<SdpVideoFormat> formats = test::HardwareVideoFormats(); |
| RtpCodecCapability rtx; |
| rtx.name = kRtxCodecName; |
| rtx.kind = MediaType::VIDEO; |
| rtx.clock_rate = kVideoCodecClockrate; |
| return { |
| ToRtpCodecCapability( |
| CreateVideoCodec(PayloadType::NotSet(), formats.front())), |
| ToRtpCodecCapability( |
| CreateVideoCodec(PayloadType::NotSet(), formats.back())), |
| rtx, |
| }; |
| } |
| |
| // The offer of a peer that only has the two codecs that the preferences above |
| // ask for. |
| std::vector<Codec> Vp8AndAv1Offer() { |
| const std::vector<SdpVideoFormat> formats = test::HardwareVideoFormats(); |
| return {CreateVideoCodec(120, formats.front()), CreateVideoRtxCodec(121, 120), |
| CreateVideoCodec(122, formats.back()), CreateVideoRtxCodec(123, 122)}; |
| } |
| |
| // Regression test for https://issues.webrtc.org/564178627, where an endpoint |
| // with hardware codecs ran out of dynamic payload types: it supports 14 video |
| // formats, each with a retransmission codec of its own, the lower range that |
| // AV1 prefers has been used up, and the application has munged codecs of its |
| // own into the upper range. The payload types that are left are only enough |
| // for the codecs that the answer can contain, so AV1, which comes last, only |
| // survives if the codecs that the transceiver's codec preferences exclude do |
| // not take them first. |
| TEST_P(CodecVendorPayloadTypeTest, |
| AnswerWithHardwareCodecMatrixUnderPayloadTypePressure) { |
| FakeMediaEngine media_engine; |
| media_engine.SetVideoCodecs(test::HardwareVideoCodecs()); |
| CodecVendor codec_vendor(&media_engine, /* rtx_enabled= */ true, |
| env_.field_trials()); |
| |
| // Eight payload types are left, which is enough for the four codecs of the |
| // answer but nowhere near enough for the 28 codecs of the matrix. |
| FakePayloadTypeSuggester pt_suggester; |
| OccupyPayloadTypeRange(pt_suggester, MediaType::VIDEO, 35, 63); |
| OccupyPayloadTypeRange(pt_suggester, MediaType::VIDEO, 96, 119); |
| |
| MediaDescriptionOptions options(MediaType::VIDEO, "mid", |
| RtpTransceiverDirection::kSendRecv, false); |
| options.codec_preferences = Vp8AndAv1Preferences(); |
| |
| RTCErrorOr<std::vector<Codec>> answered_codecs = |
| codec_vendor.GetNegotiatedCodecsForAnswer( |
| options, MediaSessionOptions(), RtpTransceiverDirection::kSendRecv, |
| RtpTransceiverDirection::kSendRecv, /*current_content=*/nullptr, |
| Vp8AndAv1Offer(), pt_suggester); |
| ASSERT_TRUE(answered_codecs.ok()) << answered_codecs.error().message(); |
| EXPECT_THAT(answered_codecs.value(), |
| Contains(Field(&Codec::name, StrCaseEq("VP8")))); |
| EXPECT_THAT(answered_codecs.value(), |
| Contains(Field(&Codec::name, StrCaseEq("AV1")))); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(PayloadTypesInTransport, |
| CodecVendorPayloadTypeTest, |
| ::testing::Bool(), |
| [](const ::testing::TestParamInfo<bool>& info) |
| -> std::string { |
| return info.param ? "Enabled" : "Disabled"; |
| }); |
| |
| } // namespace |
| } // namespace webrtc |
