diff --git a/pc/rtp_parameters_conversion.cc b/pc/rtp_parameters_conversion.cc index 1c0c3eed84..69bd7ef88b 100644 --- a/pc/rtp_parameters_conversion.cc +++ b/pc/rtp_parameters_conversion.cc @@ -28,174 +28,6 @@ namespace webrtc { -RTCErrorOr ToCricketFeedbackParam( - const RtcpFeedback& feedback) { - switch (feedback.type) { - case RtcpFeedbackType::CCM: - if (!feedback.message_type) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Missing message type in CCM RtcpFeedback."); - } else if (*feedback.message_type != RtcpFeedbackMessageType::FIR) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Invalid message type in CCM RtcpFeedback."); - } - return cricket::FeedbackParam(cricket::kRtcpFbParamCcm, - cricket::kRtcpFbCcmParamFir); - case RtcpFeedbackType::LNTF: - if (feedback.message_type) { - LOG_AND_RETURN_ERROR( - RTCErrorType::INVALID_PARAMETER, - "Didn't expect message type in LNTF RtcpFeedback."); - } - return cricket::FeedbackParam(cricket::kRtcpFbParamLntf); - case RtcpFeedbackType::NACK: - if (!feedback.message_type) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Missing message type in NACK RtcpFeedback."); - } - switch (*feedback.message_type) { - case RtcpFeedbackMessageType::GENERIC_NACK: - return cricket::FeedbackParam(cricket::kRtcpFbParamNack); - case RtcpFeedbackMessageType::PLI: - return cricket::FeedbackParam(cricket::kRtcpFbParamNack, - cricket::kRtcpFbNackParamPli); - default: - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Invalid message type in NACK RtcpFeedback."); - } - case RtcpFeedbackType::REMB: - if (feedback.message_type) { - LOG_AND_RETURN_ERROR( - RTCErrorType::INVALID_PARAMETER, - "Didn't expect message type in REMB RtcpFeedback."); - } - return cricket::FeedbackParam(cricket::kRtcpFbParamRemb); - case RtcpFeedbackType::TRANSPORT_CC: - if (feedback.message_type) { - LOG_AND_RETURN_ERROR( - RTCErrorType::INVALID_PARAMETER, - "Didn't expect message type in transport-cc RtcpFeedback."); - } - return cricket::FeedbackParam(cricket::kRtcpFbParamTransportCc); - } - RTC_CHECK_NOTREACHED(); -} - -RTCErrorOr ToCricketCodec(const RtpCodecParameters& codec) { - switch (codec.kind) { - case cricket::MEDIA_TYPE_AUDIO: - if (codec.kind != cricket::MEDIA_TYPE_AUDIO) { - LOG_AND_RETURN_ERROR( - RTCErrorType::INVALID_PARAMETER, - "Can't use video codec with audio sender or receiver."); - } - if (!codec.num_channels) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Missing number of channels for audio codec."); - } - if (*codec.num_channels <= 0) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE, - "Number of channels must be positive."); - } - if (!codec.clock_rate) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Missing codec clock rate."); - } - if (*codec.clock_rate <= 0) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE, - "Clock rate must be positive."); - } - break; - case cricket::MEDIA_TYPE_VIDEO: - if (codec.kind != cricket::MEDIA_TYPE_VIDEO) { - LOG_AND_RETURN_ERROR( - RTCErrorType::INVALID_PARAMETER, - "Can't use audio codec with video sender or receiver."); - } - if (codec.num_channels) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Video codec shouldn't have num_channels."); - } - if (!codec.clock_rate) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Missing codec clock rate."); - } - if (*codec.clock_rate != cricket::kVideoCodecClockrate) { - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Video clock rate must be 90000."); - } - break; - default: - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, - "Unknown codec type"); - } - - if (!cricket::IsValidRtpPayloadType(codec.payload_type)) { - char buf[40]; - rtc::SimpleStringBuilder sb(buf); - sb << "Invalid payload type: " << codec.payload_type; - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE, sb.str()); - } - - cricket::Codec cricket_codec = [&]() { - if (codec.kind == cricket::MEDIA_TYPE_AUDIO) { - return cricket::CreateAudioCodec(codec.payload_type, codec.name, - *codec.clock_rate, *codec.num_channels); - } - RTC_DCHECK(codec.kind == cricket::MEDIA_TYPE_VIDEO); - return cricket::CreateVideoCodec(codec.payload_type, codec.name); - }(); - - for (const RtcpFeedback& feedback : codec.rtcp_feedback) { - auto result = ToCricketFeedbackParam(feedback); - if (!result.ok()) { - return result.MoveError(); - } - cricket_codec.AddFeedbackParam(result.MoveValue()); - } - cricket_codec.params = codec.parameters; - return std::move(cricket_codec); -} - -RTCErrorOr> ToCricketCodecs( - const std::vector& codecs) { - std::vector cricket_codecs; - std::set seen_payload_types; - for (const RtpCodecParameters& codec : codecs) { - auto result = ToCricketCodec(codec); - if (!result.ok()) { - return result.MoveError(); - } - if (!seen_payload_types.insert(codec.payload_type).second) { - char buf[40]; - rtc::SimpleStringBuilder sb(buf); - sb << "Duplicate payload type: " << codec.payload_type; - LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER, sb.str()); - } - cricket_codecs.push_back(result.MoveValue()); - } - return std::move(cricket_codecs); -} - -RTCErrorOr ToCricketStreamParamsVec( - const std::vector& encodings) { - if (encodings.size() > 1u) { - LOG_AND_RETURN_ERROR(RTCErrorType::UNSUPPORTED_PARAMETER, - "ORTC API implementation doesn't currently " - "support simulcast or layered encodings."); - } else if (encodings.empty()) { - return cricket::StreamParamsVec(); - } - cricket::StreamParamsVec cricket_streams; - const RtpEncodingParameters& encoding = encodings[0]; - if (encoding.ssrc) { - cricket::StreamParams stream_params; - stream_params.add_ssrc(*encoding.ssrc); - cricket_streams.push_back(std::move(stream_params)); - } - return std::move(cricket_streams); -} - std::optional ToRtcpFeedback( const cricket::FeedbackParam& cricket_feedback) { if (cricket_feedback.id() == cricket::kRtcpFbParamCcm) { @@ -248,17 +80,6 @@ std::optional ToRtcpFeedback( return std::nullopt; } -std::vector ToRtpEncodings( - const cricket::StreamParamsVec& stream_params) { - std::vector rtp_encodings; - for (const cricket::StreamParams& stream_param : stream_params) { - RtpEncodingParameters rtp_encoding; - rtp_encoding.ssrc.emplace(stream_param.first_ssrc()); - rtp_encodings.push_back(std::move(rtp_encoding)); - } - return rtp_encodings; -} - RtpCodecCapability ToRtpCodecCapability(const cricket::Codec& cricket_codec) { RtpCodecCapability codec; codec.name = cricket_codec.name; @@ -359,20 +180,4 @@ RtpCapabilities ToRtpCapabilities( return capabilities; } -RtpParameters ToRtpParameters( - const std::vector& cricket_codecs, - const cricket::RtpHeaderExtensions& cricket_extensions, - const cricket::StreamParamsVec& stream_params) { - RtpParameters rtp_parameters; - for (const cricket::Codec& cricket_codec : cricket_codecs) { - rtp_parameters.codecs.push_back(ToRtpCodecParameters(cricket_codec)); - } - for (const RtpExtension& cricket_extension : cricket_extensions) { - rtp_parameters.header_extensions.emplace_back(cricket_extension.uri, - cricket_extension.id); - } - rtp_parameters.encodings = ToRtpEncodings(stream_params); - return rtp_parameters; -} - } // namespace webrtc diff --git a/pc/rtp_parameters_conversion.h b/pc/rtp_parameters_conversion.h index eab77f4af5..b188b36b56 100644 --- a/pc/rtp_parameters_conversion.h +++ b/pc/rtp_parameters_conversion.h @@ -22,54 +22,14 @@ namespace webrtc { -// NOTE: Some functions are templated for convenience, such that template-based -// code dealing with AudioContentDescription and VideoContentDescription can -// use this easily. Such methods are usable with cricket::AudioCodec and -// cricket::VideoCodec. - -//*************************************************************************** -// Functions for converting from new webrtc:: structures to old cricket:: -// structures. -// -// As the return values imply, all of these functions do validation of the -// parameters and return an error if they're invalid. It's expected that any -// default values (such as video clock rate of 90000) have been filled by the -// time the webrtc:: structure is being converted to the cricket:: one. -// -// These are expected to be used when parameters are passed into an RtpSender -// or RtpReceiver, and need to be validated and converted so they can be -// applied to the media engine level. -//*************************************************************************** - -// Returns error on invalid input. Certain message types are only valid for -// certain feedback types. -RTCErrorOr ToCricketFeedbackParam( - const RtcpFeedback& feedback); - -// Verifies that the codec kind is correct, and it has mandatory parameters -// filled, with values in valid ranges. -RTCErrorOr ToCricketCodec(const RtpCodecParameters& codec); - -// Verifies that payload types aren't duplicated, in addition to normal -// validation. -RTCErrorOr> ToCricketCodecs( - const std::vector& codecs); - -// SSRCs are allowed to be ommitted. This may be used for receive parameters -// where SSRCs are unsignaled. -RTCErrorOr ToCricketStreamParamsVec( - const std::vector& encodings); - //***************************************************************************** // Functions for converting from old cricket:: structures to new webrtc:: -// structures. Unlike the above functions, these are permissive with regards to +// structures. These are permissive with regards to // input validation; it's assumed that any necessary validation already // occurred. // -// These are expected to be used either to convert from audio/video engine -// capabilities to RtpCapabilities, or to convert from already-parsed SDP -// (in the form of cricket:: structures) to webrtc:: structures. The latter -// functionality is not yet implemented. +// These are expected to be used to convert from audio/video engine +// capabilities to RtpCapabilities. //***************************************************************************** // Returns empty value if `cricket_feedback` is a feedback type not @@ -77,21 +37,12 @@ RTCErrorOr ToCricketStreamParamsVec( std::optional ToRtcpFeedback( const cricket::FeedbackParam& cricket_feedback); -std::vector ToRtpEncodings( - const cricket::StreamParamsVec& stream_params); - -RtpCodecParameters ToRtpCodecParameters(const cricket::Codec& cricket_codec); RtpCodecCapability ToRtpCodecCapability(const cricket::Codec& cricket_codec); RtpCapabilities ToRtpCapabilities( const std::vector& cricket_codecs, const cricket::RtpHeaderExtensions& cricket_extensions); -RtpParameters ToRtpParameters( - const std::vector& cricket_codecs, - const cricket::RtpHeaderExtensions& cricket_extensions, - const cricket::StreamParamsVec& stream_params); - } // namespace webrtc #endif // PC_RTP_PARAMETERS_CONVERSION_H_ diff --git a/pc/rtp_parameters_conversion_unittest.cc b/pc/rtp_parameters_conversion_unittest.cc index 5bf5419fb3..e1b6ac2608 100644 --- a/pc/rtp_parameters_conversion_unittest.cc +++ b/pc/rtp_parameters_conversion_unittest.cc @@ -23,326 +23,6 @@ using ::testing::UnorderedElementsAre; namespace webrtc { -TEST(RtpParametersConversionTest, ToCricketFeedbackParam) { - auto result = ToCricketFeedbackParam( - {RtcpFeedbackType::CCM, RtcpFeedbackMessageType::FIR}); - EXPECT_EQ(cricket::FeedbackParam("ccm", "fir"), result.value()); - - result = ToCricketFeedbackParam(RtcpFeedback(RtcpFeedbackType::LNTF)); - EXPECT_EQ(cricket::FeedbackParam("goog-lntf"), result.value()); - - result = ToCricketFeedbackParam( - {RtcpFeedbackType::NACK, RtcpFeedbackMessageType::GENERIC_NACK}); - EXPECT_EQ(cricket::FeedbackParam("nack"), result.value()); - - result = ToCricketFeedbackParam( - {RtcpFeedbackType::NACK, RtcpFeedbackMessageType::PLI}); - EXPECT_EQ(cricket::FeedbackParam("nack", "pli"), result.value()); - - result = ToCricketFeedbackParam(RtcpFeedback(RtcpFeedbackType::REMB)); - EXPECT_EQ(cricket::FeedbackParam("goog-remb"), result.value()); - - result = ToCricketFeedbackParam(RtcpFeedback(RtcpFeedbackType::TRANSPORT_CC)); - EXPECT_EQ(cricket::FeedbackParam("transport-cc"), result.value()); -} - -TEST(RtpParametersConversionTest, ToCricketFeedbackParamErrors) { - // CCM with missing or invalid message type. - auto result = ToCricketFeedbackParam(RtcpFeedback(RtcpFeedbackType::CCM)); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - result = ToCricketFeedbackParam( - {RtcpFeedbackType::CCM, RtcpFeedbackMessageType::PLI}); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // LNTF with message type (should be left empty). - result = ToCricketFeedbackParam( - {RtcpFeedbackType::LNTF, RtcpFeedbackMessageType::GENERIC_NACK}); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // NACK with missing or invalid message type. - result = ToCricketFeedbackParam(RtcpFeedback(RtcpFeedbackType::NACK)); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - result = ToCricketFeedbackParam( - {RtcpFeedbackType::NACK, RtcpFeedbackMessageType::FIR}); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // REMB with message type (should be left empty). - result = ToCricketFeedbackParam( - {RtcpFeedbackType::REMB, RtcpFeedbackMessageType::GENERIC_NACK}); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // TRANSPORT_CC with message type (should be left empty). - result = ToCricketFeedbackParam( - {RtcpFeedbackType::TRANSPORT_CC, RtcpFeedbackMessageType::FIR}); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); -} - -TEST(RtpParametersConversionTest, ToAudioCodec) { - RtpCodecParameters codec; - codec.name = "AuDiO"; - codec.kind = cricket::MEDIA_TYPE_AUDIO; - codec.payload_type = 120; - codec.clock_rate.emplace(36000); - codec.num_channels.emplace(6); - codec.parameters["foo"] = "bar"; - codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC); - auto result = ToCricketCodec(codec); - ASSERT_TRUE(result.ok()); - - EXPECT_EQ("AuDiO", result.value().name); - EXPECT_EQ(120, result.value().id); - EXPECT_EQ(36000, result.value().clockrate); - EXPECT_EQ(6u, result.value().channels); - ASSERT_EQ(1u, result.value().params.size()); - EXPECT_EQ("bar", result.value().params["foo"]); - EXPECT_EQ(1u, result.value().feedback_params.params().size()); - EXPECT_TRUE(result.value().feedback_params.Has( - cricket::FeedbackParam("transport-cc"))); -} - -TEST(RtpParametersConversionTest, ToVideoCodec) { - RtpCodecParameters codec; - codec.name = "coolcodec"; - codec.kind = cricket::MEDIA_TYPE_VIDEO; - codec.payload_type = 101; - codec.clock_rate.emplace(90000); - codec.parameters["foo"] = "bar"; - codec.parameters["PING"] = "PONG"; - codec.rtcp_feedback.emplace_back(RtcpFeedbackType::LNTF); - codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC); - codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK, - RtcpFeedbackMessageType::PLI); - auto result = ToCricketCodec(codec); - ASSERT_TRUE(result.ok()); - - EXPECT_EQ("coolcodec", result.value().name); - EXPECT_EQ(101, result.value().id); - EXPECT_EQ(90000, result.value().clockrate); - ASSERT_EQ(2u, result.value().params.size()); - EXPECT_EQ("bar", result.value().params["foo"]); - EXPECT_EQ("PONG", result.value().params["PING"]); - EXPECT_EQ(3u, result.value().feedback_params.params().size()); - EXPECT_TRUE( - result.value().feedback_params.Has(cricket::FeedbackParam("goog-lntf"))); - EXPECT_TRUE(result.value().feedback_params.Has( - cricket::FeedbackParam("transport-cc"))); - EXPECT_TRUE(result.value().feedback_params.Has( - cricket::FeedbackParam("nack", "pli"))); -} - -// Trying to convert to an AudioCodec if the kind is "video" should fail. -TEST(RtpParametersConversionTest, ToCricketCodecInvalidKind) { - RtpCodecParameters audio_codec; - audio_codec.name = "opus"; - audio_codec.kind = cricket::MEDIA_TYPE_VIDEO; - audio_codec.payload_type = 111; - audio_codec.clock_rate.emplace(48000); - audio_codec.num_channels.emplace(2); - - RtpCodecParameters video_codec; - video_codec.name = "VP8"; - video_codec.kind = cricket::MEDIA_TYPE_AUDIO; - video_codec.payload_type = 102; - video_codec.clock_rate.emplace(90000); - - auto audio_result = ToCricketCodec(audio_codec); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, audio_result.error().type()); - - auto video_result = ToCricketCodec(video_codec); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, video_result.error().type()); - - // Sanity check that if the kind is correct, the conversion succeeds. - audio_codec.kind = cricket::MEDIA_TYPE_AUDIO; - video_codec.kind = cricket::MEDIA_TYPE_VIDEO; - audio_result = ToCricketCodec(audio_codec); - EXPECT_TRUE(audio_result.ok()); - video_result = ToCricketCodec(video_codec); - EXPECT_TRUE(video_result.ok()); -} - -TEST(RtpParametersConversionTest, ToAudioCodecInvalidParameters) { - // Missing channels. - RtpCodecParameters codec; - codec.name = "opus"; - codec.kind = cricket::MEDIA_TYPE_AUDIO; - codec.payload_type = 111; - codec.clock_rate.emplace(48000); - auto result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // Negative number of channels. - codec.num_channels.emplace(-1); - result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.error().type()); - - // Missing clock rate. - codec.num_channels.emplace(2); - codec.clock_rate.reset(); - result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // Negative clock rate. - codec.clock_rate.emplace(-48000); - result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.error().type()); - - // Sanity check that conversion succeeds if these errors are fixed. - codec.clock_rate.emplace(48000); - result = ToCricketCodec(codec); - EXPECT_TRUE(result.ok()); -} - -TEST(RtpParametersConversionTest, ToVideoCodecInvalidParameters) { - // Missing clock rate. - RtpCodecParameters codec; - codec.name = "VP8"; - codec.kind = cricket::MEDIA_TYPE_VIDEO; - codec.payload_type = 102; - auto result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // Invalid clock rate. - codec.clock_rate.emplace(48000); - result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // Channels set (should be unset). - codec.clock_rate.emplace(90000); - codec.num_channels.emplace(2); - result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // Sanity check that conversion succeeds if these errors are fixed. - codec.num_channels.reset(); - result = ToCricketCodec(codec); - EXPECT_TRUE(result.ok()); -} - -TEST(RtpParametersConversionTest, ToCricketCodecInvalidPayloadType) { - RtpCodecParameters codec; - codec.name = "VP8"; - codec.kind = cricket::MEDIA_TYPE_VIDEO; - codec.clock_rate.emplace(90000); - - codec.payload_type = -1000; - auto result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.error().type()); - - // Max payload type is 127. - codec.payload_type = 128; - result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.error().type()); - - // Sanity check that conversion succeeds with a valid payload type. - codec.payload_type = 127; - result = ToCricketCodec(codec); - EXPECT_TRUE(result.ok()); -} - -// There are already tests for ToCricketFeedbackParam, but ensure that those -// errors are propagated from ToCricketCodec. -TEST(RtpParametersConversionTest, ToCricketCodecInvalidRtcpFeedback) { - RtpCodecParameters codec; - codec.name = "VP8"; - codec.kind = cricket::MEDIA_TYPE_VIDEO; - codec.clock_rate.emplace(90000); - codec.payload_type = 99; - codec.rtcp_feedback.emplace_back(RtcpFeedbackType::CCM, - RtcpFeedbackMessageType::PLI); - - auto result = ToCricketCodec(codec); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // Sanity check that conversion succeeds without invalid feedback. - codec.rtcp_feedback.clear(); - result = ToCricketCodec(codec); - EXPECT_TRUE(result.ok()); -} - -TEST(RtpParametersConversionTest, ToCricketCodecs) { - std::vector codecs; - RtpCodecParameters codec; - codec.name = "VP8"; - codec.kind = cricket::MEDIA_TYPE_VIDEO; - codec.clock_rate.emplace(90000); - codec.payload_type = 99; - codecs.push_back(codec); - - codec.name = "VP9"; - codec.payload_type = 100; - codecs.push_back(codec); - - auto result = ToCricketCodecs(codecs); - ASSERT_TRUE(result.ok()); - ASSERT_EQ(2u, result.value().size()); - EXPECT_EQ("VP8", result.value()[0].name); - EXPECT_EQ(99, result.value()[0].id); - EXPECT_EQ("VP9", result.value()[1].name); - EXPECT_EQ(100, result.value()[1].id); -} - -TEST(RtpParametersConversionTest, ToCricketCodecsDuplicatePayloadType) { - std::vector codecs; - RtpCodecParameters codec; - codec.name = "VP8"; - codec.kind = cricket::MEDIA_TYPE_VIDEO; - codec.clock_rate.emplace(90000); - codec.payload_type = 99; - codecs.push_back(codec); - - codec.name = "VP9"; - codec.payload_type = 99; - codecs.push_back(codec); - - auto result = ToCricketCodecs(codecs); - EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type()); - - // Sanity check that this succeeds without the duplicate payload type. - codecs[1].payload_type = 120; - result = ToCricketCodecs(codecs); - EXPECT_TRUE(result.ok()); -} - -TEST(RtpParametersConversionTest, ToCricketStreamParamsVecSimple) { - std::vector encodings; - RtpEncodingParameters encoding; - encoding.ssrc.emplace(0xbaadf00d); - encodings.push_back(encoding); - auto result = ToCricketStreamParamsVec(encodings); - ASSERT_TRUE(result.ok()); - ASSERT_EQ(1u, result.value().size()); - EXPECT_EQ(1u, result.value()[0].ssrcs.size()); - EXPECT_EQ(0xbaadf00d, result.value()[0].first_ssrc()); -} - -// No encodings should be accepted; an endpoint may want to prepare a -// decoder/encoder without having something to receive/send yet. -TEST(RtpParametersConversionTest, ToCricketStreamParamsVecNoEncodings) { - std::vector encodings; - auto result = ToCricketStreamParamsVec(encodings); - ASSERT_TRUE(result.ok()); - EXPECT_EQ(0u, result.value().size()); -} - -// An encoding without SSRCs should be accepted. This could be the case when -// SSRCs aren't signaled and payload-type based demuxing is used. -TEST(RtpParametersConversionTest, ToCricketStreamParamsVecMissingSsrcs) { - std::vector encodings = {{}}; - // Creates RtxParameters with empty SSRC. - auto result = ToCricketStreamParamsVec(encodings); - ASSERT_TRUE(result.ok()); - EXPECT_EQ(0u, result.value().size()); -} - -// TODO(deadbeef): Update this test when we support multiple encodings. -TEST(RtpParametersConversionTest, ToCricketStreamParamsVecMultipleEncodings) { - std::vector encodings = {{}, {}}; - auto result = ToCricketStreamParamsVec(encodings); - EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER, result.error().type()); -} - TEST(RtpParametersConversionTest, ToRtcpFeedback) { std::optional result = ToRtcpFeedback({"ccm", "fir"}); EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::CCM, RtcpFeedbackMessageType::FIR), @@ -439,72 +119,6 @@ TEST(RtpParametersConversionTest, ToVideoRtpCodecCapability) { codec.rtcp_feedback[2]); } -TEST(RtpParametersConversionTest, ToRtpEncodingsWithEmptyStreamParamsVec) { - cricket::StreamParamsVec streams; - auto rtp_encodings = ToRtpEncodings(streams); - ASSERT_EQ(0u, rtp_encodings.size()); -} - -TEST(RtpParametersConversionTest, ToRtpEncodingsWithMultipleStreamParams) { - cricket::StreamParamsVec streams; - cricket::StreamParams stream1; - stream1.ssrcs.push_back(1111u); - - cricket::StreamParams stream2; - stream2.ssrcs.push_back(2222u); - - streams.push_back(stream1); - streams.push_back(stream2); - - auto rtp_encodings = ToRtpEncodings(streams); - ASSERT_EQ(2u, rtp_encodings.size()); - EXPECT_EQ(1111u, rtp_encodings[0].ssrc); - EXPECT_EQ(2222u, rtp_encodings[1].ssrc); -} - -TEST(RtpParametersConversionTest, ToAudioRtpCodecParameters) { - cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4); - cricket_codec.params["foo"] = "bar"; - cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc")); - RtpCodecParameters codec = ToRtpCodecParameters(cricket_codec); - - EXPECT_EQ("foo", codec.name); - EXPECT_EQ(cricket::MEDIA_TYPE_AUDIO, codec.kind); - EXPECT_EQ(50, codec.payload_type); - EXPECT_EQ(22222, codec.clock_rate); - EXPECT_EQ(4, codec.num_channels); - ASSERT_EQ(1u, codec.parameters.size()); - EXPECT_EQ("bar", codec.parameters["foo"]); - EXPECT_EQ(1u, codec.rtcp_feedback.size()); - EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::TRANSPORT_CC), - codec.rtcp_feedback[0]); -} - -TEST(RtpParametersConversionTest, ToVideoRtpCodecParameters) { - cricket::Codec cricket_codec = cricket::CreateVideoCodec(101, "VID"); - cricket_codec.clockrate = 80000; - cricket_codec.params["foo"] = "bar"; - cricket_codec.params["ANOTHER"] = "param"; - cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc")); - cricket_codec.feedback_params.Add(cricket::FeedbackParam("goog-lntf")); - cricket_codec.feedback_params.Add({"nack", "pli"}); - RtpCodecParameters codec = ToRtpCodecParameters(cricket_codec); - - EXPECT_EQ("VID", codec.name); - EXPECT_EQ(cricket::MEDIA_TYPE_VIDEO, codec.kind); - EXPECT_EQ(101, codec.payload_type); - EXPECT_EQ(80000, codec.clock_rate); - ASSERT_EQ(2u, codec.parameters.size()); - EXPECT_EQ("bar", codec.parameters["foo"]); - EXPECT_EQ("param", codec.parameters["ANOTHER"]); - EXPECT_EQ(3u, codec.rtcp_feedback.size()); - EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::TRANSPORT_CC), - codec.rtcp_feedback[0]); - EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::LNTF), codec.rtcp_feedback[1]); - EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::NACK, RtcpFeedbackMessageType::PLI), - codec.rtcp_feedback[2]); -} - // An unknown feedback param should just be ignored. TEST(RtpParametersConversionTest, ToRtpCodecCapabilityUnknownFeedbackParam) { cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4); @@ -566,34 +180,4 @@ TEST(RtpParametersConversionTest, ToRtpCapabilities) { UnorderedElementsAre(FecMechanism::RED, FecMechanism::FLEXFEC)); } -TEST(RtpParametersConversionTest, ToRtpParameters) { - cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8"); - vp8.clockrate = 90000; - - cricket::Codec red = cricket::CreateVideoCodec(102, "red"); - red.clockrate = 90000; - - cricket::Codec ulpfec = cricket::CreateVideoCodec(103, "ulpfec"); - ulpfec.clockrate = 90000; - - cricket::StreamParamsVec streams; - cricket::StreamParams stream; - stream.ssrcs.push_back(1234u); - streams.push_back(stream); - - RtpParameters rtp_parameters = - ToRtpParameters({vp8, red, ulpfec}, {{"uri", 1}, {"uri2", 3}}, streams); - ASSERT_EQ(3u, rtp_parameters.codecs.size()); - EXPECT_EQ("VP8", rtp_parameters.codecs[0].name); - EXPECT_EQ("red", rtp_parameters.codecs[1].name); - EXPECT_EQ("ulpfec", rtp_parameters.codecs[2].name); - ASSERT_EQ(2u, rtp_parameters.header_extensions.size()); - EXPECT_EQ("uri", rtp_parameters.header_extensions[0].uri); - EXPECT_EQ(1, rtp_parameters.header_extensions[0].id); - EXPECT_EQ("uri2", rtp_parameters.header_extensions[1].uri); - EXPECT_EQ(3, rtp_parameters.header_extensions[1].id); - ASSERT_EQ(1u, rtp_parameters.encodings.size()); - EXPECT_EQ(1234u, rtp_parameters.encodings[0].ssrc); -} - } // namespace webrtc