From 42043b95872b51321f508bf255d804ce3dff366b Mon Sep 17 00:00:00 2001 From: Magnus Jedvert Date: Thu, 17 Nov 2016 16:08:37 +0100 Subject: [PATCH] Stop using hardcoded payload types for video codecs This CL stops using hardcoded payload types for different video codecs and will dynamically assign them payload types incrementally from 96 to 127 instead. This CL: * Replaces 'std::vector DefaultVideoCodecList()' in webrtcvideoengine2.cc with an explicit WebRtcVideoEncoderFactory for internally supported software codecs instead. The purpose is to streamline the payload type assignment in webrtcvideoengine2.cc which will now have two encoder factories of the same WebRtcVideoEncoderFactory type; one internal and one external. * Removes webrtc::VideoEncoder::EncoderType and use cricket::VideoCodec instead. * Removes 'static VideoEncoder* Create(EncoderType codec_type)' and moves the create function to the internal encoder factory instead. * Removes video_encoder.cc. webrtc::VideoEncoder is now just an interface without any static functions. * The function GetSupportedCodecs in webrtcvideoengine2.cc unifies the internal and external codecs and assigns them payload types incrementally from 96 to 127. * Updates webrtcvideoengine2_unittest.cc and removes assumptions about what payload types will be used. BUG=webrtc:6677,webrtc:6705 R=hta@webrtc.org, ossu@webrtc.org, stefan@webrtc.org Review URL: https://codereview.webrtc.org/2493133002 . Cr-Commit-Position: refs/heads/master@{#15135} --- .../android/jni/androidmediaencoder_jni.cc | 51 ++- webrtc/api/webrtcsdp_unittest.cc | 11 +- webrtc/media/BUILD.gn | 2 + webrtc/media/base/mediaconstants.cc | 12 - webrtc/media/base/mediaconstants.h | 12 - webrtc/media/engine/internalencoderfactory.cc | 74 +++ webrtc/media/engine/internalencoderfactory.h | 45 ++ webrtc/media/engine/payload_type_mapper.cc | 25 +- .../engine/payload_type_mapper_unittest.cc | 24 +- .../videoencodersoftwarefallbackwrapper.cc | 13 +- .../videoencodersoftwarefallbackwrapper.h | 5 +- ...encodersoftwarefallbackwrapper_unittest.cc | 2 +- webrtc/media/engine/webrtcvideoengine2.cc | 231 ++++------ webrtc/media/engine/webrtcvideoengine2.h | 7 +- .../engine/webrtcvideoengine2_unittest.cc | 423 ++++++++++-------- webrtc/video/BUILD.gn | 1 - webrtc/video/end_to_end_tests.cc | 27 +- webrtc/video/video_encoder.cc | 67 --- webrtc/video/video_quality_test.cc | 9 +- webrtc/video/video_send_stream_tests.cc | 9 +- webrtc/video_encoder.h | 13 - 21 files changed, 522 insertions(+), 541 deletions(-) create mode 100644 webrtc/media/engine/internalencoderfactory.cc create mode 100644 webrtc/media/engine/internalencoderfactory.h delete mode 100644 webrtc/video/video_encoder.cc diff --git a/webrtc/api/android/jni/androidmediaencoder_jni.cc b/webrtc/api/android/jni/androidmediaencoder_jni.cc index 6fcb0fbe36..3fa307d2b6 100644 --- a/webrtc/api/android/jni/androidmediaencoder_jni.cc +++ b/webrtc/api/android/jni/androidmediaencoder_jni.cc @@ -30,6 +30,7 @@ #include "webrtc/base/timeutils.h" #include "webrtc/common_types.h" #include "webrtc/common_video/h264/h264_bitstream_parser.h" +#include "webrtc/media/engine/internalencoderfactory.h" #include "webrtc/modules/video_coding/include/video_codec_interface.h" #include "webrtc/modules/video_coding/utility/quality_scaler.h" #include "webrtc/modules/video_coding/utility/vp8_header_parser.h" @@ -96,7 +97,7 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder, public: virtual ~MediaCodecVideoEncoder(); MediaCodecVideoEncoder(JNIEnv* jni, - VideoCodecType codecType, + const cricket::VideoCodec& codec, jobject egl_context); // webrtc::VideoEncoder implementation. Everything trampolines to @@ -186,7 +187,7 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder, void LogStatistics(bool force_log); // Type of video codec. - VideoCodecType codecType_; + const cricket::VideoCodec codec_; // Valid all the time since RegisterEncodeCompleteCallback() Invoke()s to // |codec_thread_| synchronously. @@ -302,9 +303,9 @@ MediaCodecVideoEncoder::~MediaCodecVideoEncoder() { } MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni, - VideoCodecType codecType, + const cricket::VideoCodec& codec, jobject egl_context) - : codecType_(codecType), + : codec_(codec), callback_(NULL), codec_thread_(new Thread()), j_media_codec_video_encoder_class_( @@ -392,9 +393,10 @@ int32_t MediaCodecVideoEncoder::InitEncode( return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; } // Factory should guard against other codecs being used with us. - RTC_CHECK(codec_settings->codecType == codecType_) + const VideoCodecType codec_type = cricket::CodecTypeFromName(codec_.name); + RTC_CHECK(codec_settings->codecType == codec_type) << "Unsupported codec " << codec_settings->codecType << " for " - << codecType_; + << codec_type; if (sw_fallback_required_) { return WEBRTC_VIDEO_CODEC_OK; } @@ -404,9 +406,9 @@ int32_t MediaCodecVideoEncoder::InitEncode( // Scaling is disabled for VP9, but optionally enabled for VP8. // TODO(pbos): Extract automaticResizeOn out of VP8 settings. scale_ = false; - if (codecType_ == kVideoCodecVP8) { + if (codec_type == kVideoCodecVP8) { scale_ = codec_settings->VP8().automaticResizeOn; - } else if (codecType_ != kVideoCodecVP9) { + } else if (codec_type != kVideoCodecVP9) { scale_ = true; } @@ -414,8 +416,8 @@ int32_t MediaCodecVideoEncoder::InitEncode( ALOGD << "Encoder automatic resize " << (scale_ ? "enabled" : "disabled"); if (scale_) { - if (codecType_ == kVideoCodecVP8 || codecType_ == kVideoCodecH264) { - quality_scaler_.Init(codecType_, codec_settings->startBitrate, + if (codec_type == kVideoCodecVP8 || codec_type == kVideoCodecH264) { + quality_scaler_.Init(codec_type, codec_settings->startBitrate, codec_settings->width, codec_settings->height, codec_settings->maxFramerate); } else { @@ -522,8 +524,9 @@ bool MediaCodecVideoEncoder::ResetCodecOnCodecThread() { bool MediaCodecVideoEncoder::ProcessHWErrorOnCodecThread( bool reset_if_fallback_unavailable) { ALOGE << "ProcessHWErrorOnCodecThread"; - if (VideoEncoder::IsSupportedSoftware( - VideoEncoder::CodecToEncoderType(codecType_))) { + if (FindMatchingCodec( + cricket::InternalEncoderFactory::GetInstance().supported_codecs(), + codec_)) { ALOGE << "Fallback to SW encoder."; sw_fallback_required_ = true; return false; @@ -550,9 +553,9 @@ int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread( JNIEnv* jni = AttachCurrentThreadIfNeeded(); ScopedLocalRefFrame local_ref_frame(jni); - ALOGD << "InitEncodeOnCodecThread Type: " << (int)codecType_ << ", " << - width << " x " << height << ". Bitrate: " << kbps << - " kbps. Fps: " << fps; + const VideoCodecType codec_type = cricket::CodecTypeFromName(codec_.name); + ALOGD << "InitEncodeOnCodecThread Type: " << (int)codec_type << ", " << width + << " x " << height << ". Bitrate: " << kbps << " kbps. Fps: " << fps; if (kbps == 0) { kbps = last_set_bitrate_kbps_; } @@ -591,7 +594,7 @@ int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread( // We enforce no extra stride/padding in the format creation step. jobject j_video_codec_enum = JavaEnumFromIndexAndClassName( - jni, "MediaCodecVideoEncoder$VideoCodecType", codecType_); + jni, "MediaCodecVideoEncoder$VideoCodecType", codec_type); const bool encode_status = jni->CallBooleanMethod( *j_media_codec_video_encoder_, j_init_encode_method_, j_video_codec_enum, width, height, kbps, fps, @@ -1065,6 +1068,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) { } // Callback - return encoded frame. + const VideoCodecType codec_type = cricket::CodecTypeFromName(codec_.name); webrtc::EncodedImageCallback::Result callback_result( webrtc::EncodedImageCallback::Result::OK); if (callback_) { @@ -1083,8 +1087,8 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) { webrtc::CodecSpecificInfo info; memset(&info, 0, sizeof(info)); - info.codecType = codecType_; - if (codecType_ == kVideoCodecVP8) { + info.codecType = codec_type; + if (codec_type == kVideoCodecVP8) { info.codecSpecific.VP8.pictureId = picture_id_; info.codecSpecific.VP8.nonReference = false; info.codecSpecific.VP8.simulcastIdx = 0; @@ -1092,7 +1096,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) { info.codecSpecific.VP8.layerSync = false; info.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx; info.codecSpecific.VP8.keyIdx = webrtc::kNoKeyIdx; - } else if (codecType_ == kVideoCodecVP9) { + } else if (codec_type == kVideoCodecVP9) { if (key_frame) { gof_idx_ = 0; } @@ -1121,13 +1125,13 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) { // Generate a header describing a single fragment. webrtc::RTPFragmentationHeader header; memset(&header, 0, sizeof(header)); - if (codecType_ == kVideoCodecVP8 || codecType_ == kVideoCodecVP9) { + if (codec_type == kVideoCodecVP8 || codec_type == kVideoCodecVP9) { header.VerifyAndAllocateFragmentationHeader(1); header.fragmentationOffset[0] = 0; header.fragmentationLength[0] = image->_length; header.fragmentationPlType[0] = 0; header.fragmentationTimeDiff[0] = 0; - if (codecType_ == kVideoCodecVP8 && scale_) { + if (codec_type == kVideoCodecVP8 && scale_) { int qp; if (webrtc::vp8::GetQp(payload, payload_size, &qp)) { current_acc_qp_ += qp; @@ -1135,7 +1139,7 @@ bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) { image->qp_ = qp; } } - } else if (codecType_ == kVideoCodecH264) { + } else if (codec_type == kVideoCodecH264) { if (scale_) { h264_bitstream_parser_.ParseBitstream(payload, payload_size); int qp; @@ -1359,8 +1363,7 @@ webrtc::VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder( } if (FindMatchingCodec(supported_codecs_, codec)) { ALOGD << "Create HW video encoder for " << codec.name; - const VideoCodecType type = cricket::CodecTypeFromName(codec.name); - return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), type, + return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), codec, egl_context_); } ALOGW << "Can not find HW video encoder for type " << codec.name; diff --git a/webrtc/api/webrtcsdp_unittest.cc b/webrtc/api/webrtcsdp_unittest.cc index 3c6643f2aa..7941323d97 100644 --- a/webrtc/api/webrtcsdp_unittest.cc +++ b/webrtc/api/webrtcsdp_unittest.cc @@ -2083,11 +2083,12 @@ TEST_F(WebRtcSdpTest, SerializeTcpCandidates) { } TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithH264) { - if (!webrtc::H264Encoder::IsSupported()) - return; - for (const auto& codec : cricket::DefaultVideoCodecList()) { - video_desc_->AddCodec(codec); - } + cricket::VideoCodec h264_codec("H264"); + h264_codec.SetParam("profile-level-id", "42e01f"); + h264_codec.SetParam("level-asymmetry-allowed", "1"); + h264_codec.SetParam("packetization-mode", "1"); + video_desc_->AddCodec(h264_codec); + jdesc_.Initialize(desc_.Copy(), kSessionId, kSessionVersion); std::string message = webrtc::SdpSerialize(jdesc_, false); diff --git a/webrtc/media/BUILD.gn b/webrtc/media/BUILD.gn index c3d173aac8..590450bd29 100644 --- a/webrtc/media/BUILD.gn +++ b/webrtc/media/BUILD.gn @@ -81,6 +81,8 @@ rtc_static_library("rtc_media") { "base/videoframe.h", "base/videosourcebase.cc", "base/videosourcebase.h", + "engine/internalencoderfactory.cc", + "engine/internalencoderfactory.h", "engine/nullwebrtcvideoengine.h", "engine/payload_type_mapper.cc", "engine/payload_type_mapper.h", diff --git a/webrtc/media/base/mediaconstants.cc b/webrtc/media/base/mediaconstants.cc index 5acd8cdb01..bce252195a 100644 --- a/webrtc/media/base/mediaconstants.cc +++ b/webrtc/media/base/mediaconstants.cc @@ -108,17 +108,5 @@ const char kH264FmtpLevelAsymmetryAllowed[] = "level-asymmetry-allowed"; const char kH264FmtpPacketizationMode[] = "packetization-mode"; const char kH264ProfileLevelConstrainedBaseline[] = "42e01f"; -const int kDefaultVp8PlType = 100; -const int kDefaultVp9PlType = 101; -const int kDefaultH264PlType = 107; -const int kDefaultRedPlType = 116; -const int kDefaultUlpfecType = 117; -const int kDefaultFlexfecPlType = 118; -const int kDefaultRtxVp8PlType = 96; -const int kDefaultRtxVp9PlType = 97; -const int kDefaultRtxRedPlType = 98; -const int kDefaultRtxH264ConstrainedBaselinePlType = 99; -const int kDefaultRtxH264ConstrainedHighPlType = 102; - const int kDefaultVideoMaxFramerate = 60; } // namespace cricket diff --git a/webrtc/media/base/mediaconstants.h b/webrtc/media/base/mediaconstants.h index 02a7ba239e..70080c3a08 100644 --- a/webrtc/media/base/mediaconstants.h +++ b/webrtc/media/base/mediaconstants.h @@ -130,18 +130,6 @@ extern const char kH264FmtpLevelAsymmetryAllowed[]; extern const char kH264FmtpPacketizationMode[]; extern const char kH264ProfileLevelConstrainedBaseline[]; -extern const int kDefaultVp8PlType; -extern const int kDefaultVp9PlType; -extern const int kDefaultH264PlType; -extern const int kDefaultRedPlType; -extern const int kDefaultUlpfecType; -extern const int kDefaultFlexfecPlType; -extern const int kDefaultRtxVp8PlType; -extern const int kDefaultRtxVp9PlType; -extern const int kDefaultRtxRedPlType; -extern const int kDefaultRtxH264ConstrainedBaselinePlType; -extern const int kDefaultRtxH264ConstrainedHighPlType; - extern const int kDefaultVideoMaxFramerate; } // namespace cricket diff --git a/webrtc/media/engine/internalencoderfactory.cc b/webrtc/media/engine/internalencoderfactory.cc new file mode 100644 index 0000000000..f7c80a0324 --- /dev/null +++ b/webrtc/media/engine/internalencoderfactory.cc @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2016 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 "webrtc/media/engine/internalencoderfactory.h" + +#include + +#include "webrtc/modules/video_coding/codecs/h264/include/h264.h" +#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" +#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" + +namespace cricket { + +// static +WebRtcVideoEncoderFactory& InternalEncoderFactory::GetInstance() { + static InternalEncoderFactory instance; + return instance; +} + +InternalEncoderFactory::InternalEncoderFactory() { + supported_codecs_.push_back(cricket::VideoCodec(kVp8CodecName)); + if (webrtc::VP9Encoder::IsSupported()) + supported_codecs_.push_back(cricket::VideoCodec(kVp9CodecName)); + if (webrtc::H264Encoder::IsSupported()) { + cricket::VideoCodec codec(kH264CodecName); + // TODO(magjed): Move setting these parameters into webrtc::H264Encoder + // instead. + // TODO(hta): Set FMTP parameters for all codecs of type H264. + codec.SetParam(kH264FmtpProfileLevelId, + kH264ProfileLevelConstrainedBaseline); + codec.SetParam(kH264FmtpLevelAsymmetryAllowed, "1"); + codec.SetParam(kH264FmtpPacketizationMode, "1"); + supported_codecs_.push_back(std::move(codec)); + } + + supported_codecs_.push_back(cricket::VideoCodec(kRedCodecName)); + supported_codecs_.push_back(cricket::VideoCodec(kUlpfecCodecName)); +} + +InternalEncoderFactory::~InternalEncoderFactory() {} + +// WebRtcVideoEncoderFactory implementation. +webrtc::VideoEncoder* InternalEncoderFactory::CreateVideoEncoder( + const cricket::VideoCodec& codec) { + switch (CodecTypeFromName(codec.name)) { + case webrtc::kVideoCodecH264: + return webrtc::H264Encoder::Create(); + case webrtc::kVideoCodecVP8: + return webrtc::VP8Encoder::Create(); + case webrtc::kVideoCodecVP9: + return webrtc::VP9Encoder::Create(); + default: + return nullptr; + } +} + +const std::vector& +InternalEncoderFactory::supported_codecs() const { + return supported_codecs_; +} + +void InternalEncoderFactory::DestroyVideoEncoder( + webrtc::VideoEncoder* encoder) { + delete encoder; +} + +} // namespace cricket diff --git a/webrtc/media/engine/internalencoderfactory.h b/webrtc/media/engine/internalencoderfactory.h new file mode 100644 index 0000000000..357bbef383 --- /dev/null +++ b/webrtc/media/engine/internalencoderfactory.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2016 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. + */ + +#ifndef WEBRTC_MEDIA_ENGINE_INTERNALENCODERFACTORY_H_ +#define WEBRTC_MEDIA_ENGINE_INTERNALENCODERFACTORY_H_ + +#include + +#include "webrtc/base/constructormagic.h" +#include "webrtc/media/engine/webrtcvideoencoderfactory.h" + +namespace cricket { + +class InternalEncoderFactory : public WebRtcVideoEncoderFactory { + public: + static WebRtcVideoEncoderFactory& GetInstance(); + + // WebRtcVideoEncoderFactory implementation. + webrtc::VideoEncoder* CreateVideoEncoder( + const cricket::VideoCodec& codec) override; + const std::vector& supported_codecs() const override; + void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override; + + private: + // Disable overloaded virtual function warning. TODO(magjed): Remove once + // http://crbug/webrtc/6402 is fixed. + using WebRtcVideoEncoderFactory::CreateVideoEncoder; + + InternalEncoderFactory(); + virtual ~InternalEncoderFactory(); + RTC_DISALLOW_COPY_AND_ASSIGN(InternalEncoderFactory); + + std::vector supported_codecs_; +}; + +} // namespace cricket + +#endif // WEBRTC_MEDIA_ENGINE_INTERNALENCODERFACTORY_H_ diff --git a/webrtc/media/engine/payload_type_mapper.cc b/webrtc/media/engine/payload_type_mapper.cc index 477c7ab093..0d449c4e43 100644 --- a/webrtc/media/engine/payload_type_mapper.cc +++ b/webrtc/media/engine/payload_type_mapper.cc @@ -53,41 +53,18 @@ PayloadTypeMapper::PayloadTypeMapper() {{"G729", 8000, 1}, 18}, // Payload type assignments currently used by WebRTC. - // Includes video and data to reduce collisions (and thus - // reassignments). + // Includes data to reduce collisions (and thus reassignments) // RTX codecs mapping to specific video payload types - {{kRtxCodecName, 90000, 0, - {{kCodecParamAssociatedPayloadType, - std::to_string(kDefaultVp8PlType)}}}, - kDefaultRtxVp8PlType}, - {{kRtxCodecName, 90000, 0, - {{kCodecParamAssociatedPayloadType, - std::to_string(kDefaultVp9PlType)}}}, - kDefaultRtxVp9PlType}, - {{kRtxCodecName, 90000, 0, - {{kCodecParamAssociatedPayloadType, - std::to_string(kDefaultRedPlType)}}}, - kDefaultRtxRedPlType}, - {{kRtxCodecName, 90000, 0, - {{kCodecParamAssociatedPayloadType, - std::to_string(kDefaultH264PlType)}}}, - kDefaultRtxH264ConstrainedBaselinePlType}, // Other codecs - {{kVp8CodecName, 90000, 0}, kDefaultVp8PlType}, - {{kVp9CodecName, 90000, 0}, kDefaultVp9PlType}, {{kGoogleRtpDataCodecName, 0, 0}, kGoogleRtpDataCodecPlType}, {{kIlbcCodecName, 8000, 1}, 102}, {{kIsacCodecName, 16000, 1}, 103}, {{kIsacCodecName, 32000, 1}, 104}, {{kCnCodecName, 16000, 1}, 105}, {{kCnCodecName, 32000, 1}, 106}, - {{kH264CodecName, 90000, 0}, kDefaultH264PlType}, {{kGoogleSctpDataCodecName, 0, 0}, kGoogleSctpDataCodecPlType}, {{kOpusCodecName, 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}}, 111}, - {{kRedCodecName, 90000, 0}, kDefaultRedPlType}, - {{kUlpfecCodecName, 90000, 0}, kDefaultUlpfecType}, - {{kFlexfecCodecName, 90000, 0}, kDefaultFlexfecPlType}, // TODO(solenberg): Remove the hard coded 16k,32k,48k DTMF once we // assign payload types dynamically for send side as well. {{kDtmfCodecName, 48000, 1}, 110}, diff --git a/webrtc/media/engine/payload_type_mapper_unittest.cc b/webrtc/media/engine/payload_type_mapper_unittest.cc index 6ff8c0f658..628eb0cc91 100644 --- a/webrtc/media/engine/payload_type_mapper_unittest.cc +++ b/webrtc/media/engine/payload_type_mapper_unittest.cc @@ -60,28 +60,8 @@ TEST_F(PayloadTypeMapperTest, StaticPayloadTypes) { } TEST_F(PayloadTypeMapperTest, WebRTCPayloadTypes) { - // Tests that the payload mapper knows about the formats we've been using in - // WebRTC, with their hard coded values. - auto video_mapping = [this] (const char *name) { - return FindMapping({name, kVideoCodecClockrate, 0}); - }; - EXPECT_EQ(kDefaultVp8PlType, video_mapping(kVp8CodecName)); - EXPECT_EQ(kDefaultVp9PlType, video_mapping(kVp9CodecName)); - EXPECT_EQ(kDefaultH264PlType, video_mapping(kH264CodecName)); - EXPECT_EQ(kDefaultRedPlType, video_mapping(kRedCodecName)); - EXPECT_EQ(kDefaultUlpfecType, video_mapping(kUlpfecCodecName)); - EXPECT_EQ(kDefaultFlexfecPlType, video_mapping(kFlexfecCodecName)); - - auto rtx_mapping = [this] (int payload_type) { - return FindMapping({kRtxCodecName, kVideoCodecClockrate, 0, - {{ kCodecParamAssociatedPayloadType, std::to_string(payload_type)}}}); - }; - EXPECT_EQ(kDefaultRtxVp8PlType, rtx_mapping(kDefaultVp8PlType)); - EXPECT_EQ(kDefaultRtxVp9PlType, rtx_mapping(kDefaultVp9PlType)); - EXPECT_EQ(kDefaultRtxH264ConstrainedBaselinePlType, - rtx_mapping(kDefaultH264PlType)); - EXPECT_EQ(kDefaultRtxRedPlType, rtx_mapping(kDefaultRedPlType)); - + // Tests that the payload mapper knows about the audio and data formats we've + // been using in WebRTC, with their hard coded values. auto data_mapping = [this] (const char *name) { return FindMapping({name, 0, 0}); }; diff --git a/webrtc/media/engine/videoencodersoftwarefallbackwrapper.cc b/webrtc/media/engine/videoencodersoftwarefallbackwrapper.cc index cc37a91736..69a483e8b3 100644 --- a/webrtc/media/engine/videoencodersoftwarefallbackwrapper.cc +++ b/webrtc/media/engine/videoencodersoftwarefallbackwrapper.cc @@ -11,12 +11,13 @@ #include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h" #include "webrtc/base/logging.h" +#include "webrtc/media/engine/internalencoderfactory.h" #include "webrtc/modules/video_coding/include/video_error_codes.h" namespace webrtc { VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper( - VideoCodecType codec_type, + const cricket::VideoCodec& codec, webrtc::VideoEncoder* encoder) : number_of_cores_(0), max_payload_size_(0), @@ -25,17 +26,19 @@ VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper( channel_parameters_set_(false), packet_loss_(0), rtt_(0), - encoder_type_(CodecToEncoderType(codec_type)), + codec_(codec), encoder_(encoder), callback_(nullptr) {} bool VideoEncoderSoftwareFallbackWrapper::InitFallbackEncoder() { - if (!VideoEncoder::IsSupportedSoftware(encoder_type_)) { + cricket::WebRtcVideoEncoderFactory& internal_factory = + cricket::InternalEncoderFactory::GetInstance(); + if (!FindMatchingCodec(internal_factory.supported_codecs(), codec_)) { LOG(LS_WARNING) << "Encoder requesting fallback to codec not supported in software."; return false; } - fallback_encoder_.reset(VideoEncoder::Create(encoder_type_)); + fallback_encoder_.reset(internal_factory.CreateVideoEncoder(codec_)); if (fallback_encoder_->InitEncode(&codec_settings_, number_of_cores_, max_payload_size_) != WEBRTC_VIDEO_CODEC_OK) { @@ -77,7 +80,7 @@ int32_t VideoEncoderSoftwareFallbackWrapper::InitEncode( int32_t ret = encoder_->InitEncode(codec_settings, number_of_cores, max_payload_size); - if (ret == WEBRTC_VIDEO_CODEC_OK || encoder_type_ == kUnsupportedCodec) { + if (ret == WEBRTC_VIDEO_CODEC_OK || codec_.name.empty()) { if (fallback_encoder_) fallback_encoder_->Release(); fallback_encoder_.reset(); diff --git a/webrtc/media/engine/videoencodersoftwarefallbackwrapper.h b/webrtc/media/engine/videoencodersoftwarefallbackwrapper.h index 5d81f4ac1e..05e815df46 100644 --- a/webrtc/media/engine/videoencodersoftwarefallbackwrapper.h +++ b/webrtc/media/engine/videoencodersoftwarefallbackwrapper.h @@ -15,6 +15,7 @@ #include #include +#include "webrtc/media/base/codec.h" #include "webrtc/video_encoder.h" namespace webrtc { @@ -24,7 +25,7 @@ namespace webrtc { // hardware restrictions, such as max resolution. class VideoEncoderSoftwareFallbackWrapper : public VideoEncoder { public: - VideoEncoderSoftwareFallbackWrapper(VideoCodecType codec_type, + VideoEncoderSoftwareFallbackWrapper(const cricket::VideoCodec& codec, webrtc::VideoEncoder* encoder); int32_t InitEncode(const VideoCodec* codec_settings, @@ -63,7 +64,7 @@ class VideoEncoderSoftwareFallbackWrapper : public VideoEncoder { uint32_t packet_loss_; int64_t rtt_; - const EncoderType encoder_type_; + const cricket::VideoCodec codec_; webrtc::VideoEncoder* const encoder_; std::unique_ptr fallback_encoder_; diff --git a/webrtc/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc b/webrtc/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc index 42d6b473cd..ca06e9256d 100644 --- a/webrtc/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc +++ b/webrtc/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc @@ -28,7 +28,7 @@ const size_t kMaxPayloadSize = 800; class VideoEncoderSoftwareFallbackWrapperTest : public ::testing::Test { protected: VideoEncoderSoftwareFallbackWrapperTest() - : fallback_wrapper_(kVideoCodecVP8, &fake_encoder_) {} + : fallback_wrapper_(cricket::VideoCodec("VP8"), &fake_encoder_) {} class CountingFakeEncoder : public VideoEncoder { public: diff --git a/webrtc/media/engine/webrtcvideoengine2.cc b/webrtc/media/engine/webrtcvideoengine2.cc index c43dff80d3..646ed8e447 100644 --- a/webrtc/media/engine/webrtcvideoengine2.cc +++ b/webrtc/media/engine/webrtcvideoengine2.cc @@ -24,14 +24,13 @@ #include "webrtc/call.h" #include "webrtc/common_video/h264/profile_level_id.h" #include "webrtc/media/engine/constants.h" +#include "webrtc/media/engine/internalencoderfactory.h" #include "webrtc/media/engine/simulcast.h" #include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h" #include "webrtc/media/engine/webrtcmediaengine.h" #include "webrtc/media/engine/webrtcvideoencoderfactory.h" #include "webrtc/media/engine/webrtcvoiceengine.h" -#include "webrtc/modules/video_coding/codecs/h264/include/h264.h" #include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h" -#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" #include "webrtc/system_wrappers/include/field_trial.h" #include "webrtc/video_decoder.h" #include "webrtc/video_encoder.h" @@ -170,13 +169,6 @@ void AddDefaultFeedbackParams(VideoCodec* codec) { FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty)); } -static VideoCodec MakeVideoCodecWithDefaultFeedbackParams(int payload_type, - const char* name) { - VideoCodec codec(payload_type, name); - AddDefaultFeedbackParams(&codec); - return codec; -} - static std::string CodecVectorToString(const std::vector& codecs) { std::stringstream out; out << '{'; @@ -392,73 +384,6 @@ static const int kDefaultRtcpReceiverReportSsrc = 1; // Minimum time interval for logging stats. static const int64_t kStatsLogIntervalMs = 10000; -// Adds |codec| to |list|, and also adds an RTX codec if |codec|'s name is -// recognized. -// TODO(deadbeef): Should we add RTX codecs for external codecs whose names we -// don't recognize? -void AddCodecAndMaybeRtxCodec(const VideoCodec& codec, - std::vector* codecs) { - codecs->push_back(codec); - int rtx_payload_type = 0; - if (CodecNamesEq(codec.name, kVp8CodecName)) { - rtx_payload_type = kDefaultRtxVp8PlType; - } else if (CodecNamesEq(codec.name, kVp9CodecName)) { - rtx_payload_type = kDefaultRtxVp9PlType; - } else if (CodecNamesEq(codec.name, kH264CodecName)) { - // Parse H264 profile. - const rtc::Optional profile_level_id = - webrtc::H264::ParseSdpProfileLevelId(codec.params); - if (!profile_level_id) - return; - const webrtc::H264::Profile profile = profile_level_id->profile; - // In H.264, we only support rtx for constrained baseline and constrained - // high profile. - if (profile == webrtc::H264::kProfileConstrainedBaseline) { - rtx_payload_type = kDefaultRtxH264ConstrainedBaselinePlType; - } else if (profile == webrtc::H264::kProfileConstrainedHigh) { - rtx_payload_type = kDefaultRtxH264ConstrainedHighPlType; - } else { - return; - } - } else if (CodecNamesEq(codec.name, kRedCodecName)) { - rtx_payload_type = kDefaultRtxRedPlType; - } else { - return; - } - codecs->push_back(VideoCodec::CreateRtxCodec(rtx_payload_type, codec.id)); -} - -std::vector DefaultVideoCodecList() { - std::vector codecs; - AddCodecAndMaybeRtxCodec( - MakeVideoCodecWithDefaultFeedbackParams(kDefaultVp8PlType, kVp8CodecName), - &codecs); - if (webrtc::VP9Encoder::IsSupported() && webrtc::VP9Decoder::IsSupported()) { - AddCodecAndMaybeRtxCodec(MakeVideoCodecWithDefaultFeedbackParams( - kDefaultVp9PlType, kVp9CodecName), - &codecs); - } - if (webrtc::H264Encoder::IsSupported() && - webrtc::H264Decoder::IsSupported()) { - VideoCodec codec = MakeVideoCodecWithDefaultFeedbackParams( - kDefaultH264PlType, kH264CodecName); - // TODO(hta): Move all parameter generation for SDP into the codec - // implementation, for all codecs and parameters. - // TODO(hta): Move selection of profile-level-id to H.264 codec - // implementation. - // TODO(hta): Set FMTP parameters for all codecs of type H264. - codec.SetParam(kH264FmtpProfileLevelId, - kH264ProfileLevelConstrainedBaseline); - codec.SetParam(kH264FmtpLevelAsymmetryAllowed, "1"); - codec.SetParam(kH264FmtpPacketizationMode, "1"); - AddCodecAndMaybeRtxCodec(codec, &codecs); - } - AddCodecAndMaybeRtxCodec(VideoCodec(kDefaultRedPlType, kRedCodecName), - &codecs); - codecs.push_back(VideoCodec(kDefaultUlpfecType, kUlpfecCodecName)); - return codecs; -} - static std::vector GetSupportedCodecs( const WebRtcVideoEncoderFactory* external_encoder_factory); @@ -634,50 +559,87 @@ void WebRtcVideoEngine2::SetExternalEncoderFactory( video_codecs_ = GetSupportedCodecs(encoder_factory); } -static std::vector GetSupportedCodecs( - const WebRtcVideoEncoderFactory* external_encoder_factory) { - std::vector supported_codecs = DefaultVideoCodecList(); - - if (external_encoder_factory == nullptr) { - LOG(LS_INFO) << "Supported codecs: " - << CodecVectorToString(supported_codecs); - return supported_codecs; - } - - std::stringstream out; - const std::vector& codecs = - external_encoder_factory->supported_codecs(); - for (size_t i = 0; i < codecs.size(); ++i) { - VideoCodec codec = codecs[i]; - out << codec.name; - if (i != codecs.size() - 1) { - out << ", "; +// This is a helper function for AppendVideoCodecs below. It will return the +// first unused dynamic payload type (in the range [96, 127]), or nothing if no +// payload type is unused. +static rtc::Optional NextFreePayloadType( + const std::vector& codecs) { + static const int kFirstDynamicPayloadType = 96; + static const int kLastDynamicPayloadType = 127; + bool is_payload_used[1 + kLastDynamicPayloadType - kFirstDynamicPayloadType] = + {false}; + for (const VideoCodec& codec : codecs) { + if (kFirstDynamicPayloadType <= codec.id && + codec.id <= kLastDynamicPayloadType) { + is_payload_used[codec.id - kFirstDynamicPayloadType] = true; } - // Don't add internally-supported codecs twice. - if (FindMatchingCodec(supported_codecs, codec)) + } + for (int i = kFirstDynamicPayloadType; i <= kLastDynamicPayloadType; ++i) { + if (!is_payload_used[i - kFirstDynamicPayloadType]) + return rtc::Optional(i); + } + // No free payload type. + return rtc::Optional(); +} + +// This is a helper function for GetSupportedCodecs below. It will append new +// unique codecs from |input_codecs| to |unified_codecs|. It will add default +// feedback params to the codecs and will also add an associated RTX codec for +// recognized codecs (VP8, VP9, H264, and Red). +static void AppendVideoCodecs(const std::vector& input_codecs, + std::vector* unified_codecs) { + for (VideoCodec codec : input_codecs) { + const rtc::Optional payload_type = + NextFreePayloadType(*unified_codecs); + if (!payload_type) + return; + codec.id = *payload_type; + // TODO(magjed): Move the responsibility of setting these parameters to the + // encoder factories instead. + if (codec.name != kRedCodecName && codec.name != kUlpfecCodecName) + AddDefaultFeedbackParams(&codec); + // Don't add same codec twice. + if (FindMatchingCodec(*unified_codecs, codec)) continue; - // External video encoders are given payloads 120-127. This also means that - // we only support up to 8 external payload types. - // TODO(deadbeef): mediasession.cc already has code to dynamically - // determine a payload type. We should be able to just leave the payload - // type empty and let mediasession determine it. However, currently RTX - // codecs are associated to codecs by payload type, meaning we DO need - // to allocate unique payload types here. So to make this change we would - // need to make RTX codecs associated by name instead. - const int kExternalVideoPayloadTypeBase = 120; - size_t payload_type = kExternalVideoPayloadTypeBase + i; - RTC_DCHECK(payload_type < 128); - codec.id = payload_type; + unified_codecs->push_back(codec); - AddDefaultFeedbackParams(&codec); - AddCodecAndMaybeRtxCodec(codec, &supported_codecs); + // Add associated RTX codec for recognized codecs. + // TODO(deadbeef): Should we add RTX codecs for external codecs whose names + // we don't recognize? + if (CodecNamesEq(codec.name, kVp8CodecName) || + CodecNamesEq(codec.name, kVp9CodecName) || + CodecNamesEq(codec.name, kH264CodecName) || + CodecNamesEq(codec.name, kRedCodecName)) { + const rtc::Optional rtx_payload_type = + NextFreePayloadType(*unified_codecs); + if (!rtx_payload_type) + return; + unified_codecs->push_back( + VideoCodec::CreateRtxCodec(*rtx_payload_type, codec.id)); + } } - LOG(LS_INFO) << "Supported codecs (incl. external codecs): " - << CodecVectorToString(supported_codecs); - LOG(LS_INFO) << "Codecs supported by the external encoder factory: " - << out.str(); - return supported_codecs; +} + +static std::vector GetSupportedCodecs( + const WebRtcVideoEncoderFactory* external_encoder_factory) { + const std::vector& internal_codecs = + InternalEncoderFactory::GetInstance().supported_codecs(); + LOG(LS_INFO) << "Internally supported codecs: " + << CodecVectorToString(internal_codecs); + + std::vector unified_codecs; + AppendVideoCodecs(internal_codecs, &unified_codecs); + + if (external_encoder_factory != nullptr) { + const std::vector& external_codecs = + external_encoder_factory->supported_codecs(); + AppendVideoCodecs(external_codecs, &unified_codecs); + LOG(LS_INFO) << "Codecs supported by the external encoder factory: " + << CodecVectorToString(external_codecs); + } + + return unified_codecs; } WebRtcVideoChannel2::WebRtcVideoChannel2( @@ -1555,16 +1517,16 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters:: WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder( webrtc::VideoEncoder* encoder, - webrtc::VideoCodecType type, + const cricket::VideoCodec& codec, bool external) : encoder(encoder), external_encoder(nullptr), - type(type), + codec(codec), external(external) { if (external) { external_encoder = encoder; this->encoder = - new webrtc::VideoEncoderSoftwareFallbackWrapper(type, encoder); + new webrtc::VideoEncoderSoftwareFallbackWrapper(codec, encoder); } } @@ -1592,7 +1554,7 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream( encoder_sink_(nullptr), parameters_(std::move(config), options, max_bitrate_bps, codec_settings), rtp_parameters_(CreateRtpParametersWithOneEncoding()), - allocated_encoder_(nullptr, webrtc::kVideoCodecUnknown, false), + allocated_encoder_(nullptr, cricket::VideoCodec(), false), sending_(false), last_frame_timestamp_us_(0) { parameters_.config.rtp.max_packet_size = kVideoMtu; @@ -1727,36 +1689,33 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder( const VideoCodec& codec) { RTC_DCHECK_RUN_ON(&thread_checker_); - webrtc::VideoCodecType type = CodecTypeFromName(codec.name); - // Do not re-create encoders of the same type. - if (type == allocated_encoder_.type && allocated_encoder_.encoder != NULL) { + if (codec == allocated_encoder_.codec && + allocated_encoder_.encoder != nullptr) { return allocated_encoder_; } - if (external_encoder_factory_ != NULL) { + // Try creating external encoder. + if (external_encoder_factory_ != nullptr && + FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) { webrtc::VideoEncoder* encoder = external_encoder_factory_->CreateVideoEncoder(codec); - if (encoder != NULL) { - return AllocatedEncoder(encoder, type, true); - } + if (encoder != nullptr) + return AllocatedEncoder(encoder, codec, true /* is_external */); } - if (type == webrtc::kVideoCodecVP8) { - return AllocatedEncoder( - webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp8), type, false); - } else if (type == webrtc::kVideoCodecVP9) { - return AllocatedEncoder( - webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp9), type, false); - } else if (type == webrtc::kVideoCodecH264) { - return AllocatedEncoder( - webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kH264), type, false); + // Try creating internal encoder. + WebRtcVideoEncoderFactory& internal_encoder_factory = + InternalEncoderFactory::GetInstance(); + if (FindMatchingCodec(internal_encoder_factory.supported_codecs(), codec)) { + return AllocatedEncoder(internal_encoder_factory.CreateVideoEncoder(codec), + codec, false /* is_external */); } // This shouldn't happen, we should not be trying to create something we don't // support. RTC_DCHECK(false); - return AllocatedEncoder(NULL, webrtc::kVideoCodecUnknown, false); + return AllocatedEncoder(NULL, cricket::VideoCodec(), false); } void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder( diff --git a/webrtc/media/engine/webrtcvideoengine2.h b/webrtc/media/engine/webrtcvideoengine2.h index 28dfb9773a..546799ec88 100644 --- a/webrtc/media/engine/webrtcvideoengine2.h +++ b/webrtc/media/engine/webrtcvideoengine2.h @@ -61,9 +61,6 @@ class WebRtcVoiceMediaChannel; struct Device; -// Exposed here for unittests. -std::vector DefaultVideoCodecList(); - class UnsignalledSsrcHandler { public: enum Action { @@ -301,11 +298,11 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport { struct AllocatedEncoder { AllocatedEncoder(webrtc::VideoEncoder* encoder, - webrtc::VideoCodecType type, + const cricket::VideoCodec& codec, bool external); webrtc::VideoEncoder* encoder; webrtc::VideoEncoder* external_encoder; - webrtc::VideoCodecType type; + cricket::VideoCodec codec; bool external; }; diff --git a/webrtc/media/engine/webrtcvideoengine2_unittest.cc b/webrtc/media/engine/webrtcvideoengine2_unittest.cc index 19b7d644cd..70de26711a 100644 --- a/webrtc/media/engine/webrtcvideoengine2_unittest.cc +++ b/webrtc/media/engine/webrtcvideoengine2_unittest.cc @@ -33,13 +33,6 @@ using webrtc::RtpExtension; namespace { static const int kDefaultQpMax = 56; -static const cricket::VideoCodec kVp8Codec(100, "VP8"); -static const cricket::VideoCodec kVp9Codec(101, "VP9"); -static const cricket::VideoCodec kH264Codec(102, "H264"); - -static const cricket::VideoCodec kRedCodec(116, "red"); -static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec"); - static const uint8_t kRedRtxPayloadType = 125; static const uint32_t kSsrcs1[] = {1}; @@ -49,6 +42,11 @@ static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE; static const char kUnsupportedExtensionName[] = "urn:ietf:params:rtp-hdrext:unsupported"; +cricket::VideoCodec RemoveFeedbackParams(cricket::VideoCodec&& codec) { + codec.feedback_params = cricket::FeedbackParams(); + return codec; +} + void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) { EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( cricket::kRtcpFbParamNack, cricket::kParamValueEmpty))); @@ -113,19 +111,15 @@ class WebRtcVideoEngine2Test : public ::testing::Test { std::vector engine_codecs = engine_.codecs(); RTC_DCHECK(!engine_codecs.empty()); bool codec_set = false; - for (size_t i = 0; i < engine_codecs.size(); ++i) { - if (engine_codecs[i].name == "red") { - default_red_codec_ = engine_codecs[i]; - } else if (engine_codecs[i].name == "ulpfec") { - default_ulpfec_codec_ = engine_codecs[i]; - } else if (engine_codecs[i].name == "rtx") { + for (const cricket::VideoCodec& codec : engine_codecs) { + if (codec.name == "rtx") { int associated_payload_type; - if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType, - &associated_payload_type)) { - default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id; + if (codec.GetParam(kCodecParamAssociatedPayloadType, + &associated_payload_type)) { + default_apt_rtx_types_[associated_payload_type] = codec.id; } - } else if (!codec_set) { - default_codec_ = engine_codecs[i]; + } else if (!codec_set && codec.name != "red" && codec.name != "ulpfec") { + default_codec_ = codec; codec_set = true; } } @@ -134,9 +128,12 @@ class WebRtcVideoEngine2Test : public ::testing::Test { } protected: + // Find the codec in the engine with the given name. The codec must be + // present. + cricket::VideoCodec GetEngineCodec(const std::string& name); + VideoMediaChannel* SetUpForExternalEncoderFactory( - cricket::WebRtcVideoEncoderFactory* encoder_factory, - const std::vector& codecs); + cricket::WebRtcVideoEncoderFactory* encoder_factory); VideoMediaChannel* SetUpForExternalDecoderFactory( cricket::WebRtcVideoDecoderFactory* decoder_factory, @@ -151,8 +148,6 @@ class WebRtcVideoEngine2Test : public ::testing::Test { std::unique_ptr call_; WebRtcVideoEngine2 engine_; VideoCodec default_codec_; - VideoCodec default_red_codec_; - VideoCodec default_ulpfec_codec_; std::map default_apt_rtx_types_; }; @@ -240,15 +235,15 @@ TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("VP8"); - cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); // Add CVO extension. const int id = 1; + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, id)); EXPECT_TRUE(channel->SetSendParameters(parameters)); @@ -272,13 +267,13 @@ TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("VP8"); - cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); // Add CVO extension. const int id = 1; + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, id)); EXPECT_TRUE(channel->SetSendParameters(parameters)); @@ -297,12 +292,9 @@ TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("VP8"); encoder_factory.AddSupportedVideoCodecType("VP9"); - cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp9Codec); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); // Set capturer. @@ -313,6 +305,9 @@ TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) { // Add CVO extension. const int id = 1; + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.extensions.push_back( RtpExtension(RtpExtension::kVideoRotationUri, id)); // Also remove the first codec to trigger a codec change as well. @@ -353,11 +348,9 @@ TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) { TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("VP8"); - cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); EXPECT_TRUE( channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); @@ -378,6 +371,8 @@ TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) { // Setting codecs of the same type should not reallocate any encoders // (expecting a no-op). + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(channel->SetSendParameters(parameters)); EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders()); @@ -416,13 +411,13 @@ TEST_F(WebRtcVideoEngine2Test, RtxCodecAddedForExternalCodec) { // First figure out what payload types the test codecs got assigned. const std::vector codecs = engine_.codecs(); - // Now search for RTX codecs for them. Expect that Constrained Baseline and - // Constrained High got an associated RTX codec, but not High. + // Now search for RTX codecs for them. Expect that they all have associated + // RTX codecs. EXPECT_TRUE(HasRtxCodec( codecs, FindMatchingCodec(codecs, h264_constrained_baseline)->id)); EXPECT_TRUE(HasRtxCodec( codecs, FindMatchingCodec(codecs, h264_constrained_high)->id)); - EXPECT_FALSE(HasRtxCodec( + EXPECT_TRUE(HasRtxCodec( codecs, FindMatchingCodec(codecs, h264_high)->id)); } @@ -430,14 +425,11 @@ void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse( bool use_external_encoder) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("VP8"); - cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); std::unique_ptr channel; FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_)); call_.reset(fake_call); if (use_external_encoder) { - channel.reset( - SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); + channel.reset(SetUpForExternalEncoderFactory(&encoder_factory)); } else { engine_.Init(); channel.reset( @@ -445,6 +437,8 @@ void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse( } ASSERT_TRUE( channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(channel->SetSendParameters(parameters)); EXPECT_TRUE(channel->SetSend(true)); FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0]; @@ -467,11 +461,9 @@ TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) { TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("VP9"); - std::vector codecs; - codecs.push_back(kVp9Codec); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); EXPECT_TRUE( channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); @@ -481,12 +473,10 @@ TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) { TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("VP8"); - std::vector codecs; - codecs.push_back(kVp8Codec); FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_)); call_.reset(fake_call); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); EXPECT_TRUE( channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); @@ -536,16 +526,29 @@ TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) { EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); } +cricket::VideoCodec WebRtcVideoEngine2Test::GetEngineCodec( + const std::string& name) { + for (const cricket::VideoCodec& engine_codec : engine_.codecs()) { + if (CodecNamesEq(name, engine_codec.name)) + return engine_codec; + } + // This point should never be reached. + ADD_FAILURE() << "Unrecognized codec name: " << name; + return cricket::VideoCodec(); +} + VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory( - cricket::WebRtcVideoEncoderFactory* encoder_factory, - const std::vector& codecs) { + cricket::WebRtcVideoEncoderFactory* encoder_factory) { engine_.SetExternalEncoderFactory(encoder_factory); engine_.Init(); VideoMediaChannel* channel = engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()); cricket::VideoSendParameters parameters; - parameters.codecs = codecs; + // We need to look up the codec in the engine to get the correct payload type. + for (const VideoCodec& codec : encoder_factory->supported_codecs()) + parameters.codecs.push_back(GetEngineCodec(codec.name)); + EXPECT_TRUE(channel->SetSendParameters(parameters)); return channel; @@ -569,11 +572,9 @@ VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory( TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("VP8"); - std::vector codecs; - codecs.push_back(kVp8Codec); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -610,18 +611,16 @@ TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("H264"); - std::vector codecs; - codecs.push_back(kH264Codec); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); EXPECT_TRUE( channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); ASSERT_EQ(1u, encoder_factory.encoders().size()); cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(channel->SetSendParameters(parameters)); ASSERT_EQ(0u, encoder_factory.encoders().size()); } @@ -630,11 +629,15 @@ TEST_F(WebRtcVideoEngine2Test, DontUseExternalEncoderFactoryForUnsupportedCodecs) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("H264"); - std::vector codecs; - codecs.push_back(kVp8Codec); + + engine_.SetExternalEncoderFactory(&encoder_factory); + engine_.Init(); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, codecs)); + engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); + EXPECT_TRUE(channel->SetSendParameters(parameters)); EXPECT_TRUE( channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); @@ -648,11 +651,14 @@ TEST_F(WebRtcVideoEngine2Test, encoder_factory.AddSupportedVideoCodecType("VP8"); encoder_factory.AddSupportedVideoCodecType("H264"); - std::vector codecs; - codecs.push_back(kVp8Codec); + engine_.SetExternalEncoderFactory(&encoder_factory); + engine_.Init(); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, codecs)); + engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); + EXPECT_TRUE(channel->SetSendParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); @@ -685,11 +691,14 @@ TEST_F(WebRtcVideoEngine2Test, encoder_factory.AddSupportedVideoCodecType("VP8"); encoder_factory.AddSupportedVideoCodecType("H264"); - std::vector codecs; - codecs.push_back(kH264Codec); + engine_.SetExternalEncoderFactory(&encoder_factory); + engine_.Init(); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, codecs)); + engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("H264")); + EXPECT_TRUE(channel->SetSendParameters(parameters)); EXPECT_TRUE( channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); @@ -714,11 +723,9 @@ TEST_F(WebRtcVideoEngine2Test, TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) { cricket::FakeWebRtcVideoEncoderFactory encoder_factory; encoder_factory.AddSupportedVideoCodecType("H264"); - std::vector codecs; - codecs.push_back(kH264Codec); std::unique_ptr channel( - SetUpForExternalEncoderFactory(&encoder_factory, codecs)); + SetUpForExternalEncoderFactory(&encoder_factory)); const std::vector ssrcs = MAKE_VECTOR(kSsrcs3); EXPECT_TRUE( @@ -761,7 +768,7 @@ TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) { cricket::FakeWebRtcVideoDecoderFactory decoder_factory; decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); std::unique_ptr channel( SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs)); @@ -791,7 +798,7 @@ TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) { cricket::FakeWebRtcVideoDecoderFactory decoder_factory; decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264); std::vector codecs; - codecs.push_back(kH264Codec); + codecs.push_back(GetEngineCodec("H264")); std::unique_ptr channel( SetUpForExternalDecoderFactory(&decoder_factory, codecs)); @@ -806,7 +813,17 @@ class WebRtcVideoChannel2BaseTest protected: typedef VideoMediaChannelTest Base; - cricket::VideoCodec DefaultCodec() override { return kVp8Codec; } + cricket::VideoCodec GetEngineCodec(const std::string& name) { + for (const cricket::VideoCodec& engine_codec : engine_.codecs()) { + if (CodecNamesEq(name, engine_codec.name)) + return engine_codec; + } + // This point should never be reached. + ADD_FAILURE() << "Unrecognized codec name: " << name; + return cricket::VideoCodec(); + } + + cricket::VideoCodec DefaultCodec() override { return GetEngineCodec("VP8"); } }; // Verifies that id given in stream params is passed to the decoder factory. @@ -814,7 +831,7 @@ TEST_F(WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory) { cricket::FakeWebRtcVideoDecoderFactory decoder_factory; decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); std::unique_ptr channel( SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs)); @@ -865,15 +882,15 @@ WEBRTC_BASE_TEST(RejectEmptyStreamParams); WEBRTC_BASE_TEST(MultipleSendStreams); TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) { - SendAndReceive(cricket::VideoCodec(100, "VP8")); + SendAndReceive(GetEngineCodec("VP8")); } TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) { - SendAndReceive(cricket::VideoCodec(100, "VP8")); + SendAndReceive(GetEngineCodec("VP8")); } TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) { - SendAndReceive(cricket::VideoCodec(100, "VP8")); + SendAndReceive(GetEngineCodec("VP8")); } TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) { @@ -882,7 +899,7 @@ TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) { // initially will use QVGA instead of VGA. // TODO(pbos): Set up the quality scaler so that both senders reliably start // at QVGA, then verify that instead. - cricket::VideoCodec codec = kVp8Codec; + cricket::VideoCodec codec = GetEngineCodec("VP8"); codec.params[kCodecParamStartBitrate] = "1000000"; Base::TwoStreamsSendAndReceive(codec); } @@ -942,7 +959,7 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test { int expected_max_bitrate_bps) { auto& codecs = send_parameters_.codecs; codecs.clear(); - codecs.push_back(kVp8Codec); + codecs.push_back(GetEngineCodec("VP8")); codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps; codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps; codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps; @@ -1054,8 +1071,8 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test { void TestCpuAdaptation(bool enable_overuse, bool is_screenshare); void TestReceiverLocalSsrcConfiguration(bool receiver_first); - void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type, - bool expect_created_receive_stream); + void TestReceiveUnsignaledSsrcPacket(uint8_t payload_type, + bool expect_created_receive_stream); FakeVideoSendStream* SetDenoisingOption( uint32_t ssrc, @@ -1429,7 +1446,7 @@ TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) { // Verify that REMB is turned off when send(!) codecs without REMB are set. cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); EXPECT_TRUE(channel_->SetSendParameters(parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; @@ -1450,7 +1467,7 @@ TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) { // Verify that transport cc feedback is turned off when send(!) codecs without // transport cc feedback are set. cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); EXPECT_TRUE(channel_->SetSendParameters(parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; @@ -1496,7 +1513,7 @@ TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) { // Verify that NACK is turned off when send(!) codecs without NACK are set. cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); EXPECT_TRUE(channel_->SetSendParameters(parameters)); recv_stream = fake_call_->GetVideoReceiveStreams()[0]; @@ -1521,7 +1538,7 @@ TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) { // earlier. TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); channel_->SetSend(false); @@ -1548,7 +1565,7 @@ TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) { TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { static const int kScreenshareMinBitrateKbps = 800; - cricket::VideoCodec codec = kVp8Codec; + cricket::VideoCodec codec = GetEngineCodec("VP8"); cricket::VideoSendParameters parameters; parameters.codecs.push_back(codec); EXPECT_TRUE(channel_->SetSendParameters(parameters)); @@ -1737,7 +1754,7 @@ TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) { TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); // Single-stream settings should apply with RTX as well (verifies that we @@ -1818,7 +1835,7 @@ TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) { EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capturer.GetSupportedFormats()->front())); cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); @@ -1867,7 +1884,7 @@ class Vp9SettingsTest : public WebRtcVideoChannel2Test { TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(false, false); @@ -1927,7 +1944,7 @@ class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest { protected: void VerifySettings(int num_spatial_layers, int num_temporal_layers) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP9")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = SetUpSimulcast(false, false); @@ -1998,7 +2015,7 @@ TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) { } TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) { - cricket::VideoCodec codec = kVp8Codec; + cricket::VideoCodec codec = GetEngineCodec("VP8"); cricket::VideoSendParameters parameters; parameters.codecs.push_back(codec); @@ -2072,7 +2089,7 @@ TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) { } TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) { - cricket::VideoCodec codec = kVp8Codec; + cricket::VideoCodec codec = GetEngineCodec("VP8"); cricket::VideoSendParameters parameters; parameters.codecs.push_back(codec); @@ -2136,7 +2153,7 @@ TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) { void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse, bool is_screenshare) { - cricket::VideoCodec codec = kVp8Codec; + cricket::VideoCodec codec = GetEngineCodec("VP8"); cricket::VideoSendParameters parameters; parameters.codecs.push_back(codec); @@ -2260,8 +2277,8 @@ TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) { // Make sure NACK and FEC are enabled on the correct payload types. EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms); - EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.ulpfec.ulpfec_payload_type); - EXPECT_EQ(default_red_codec_.id, config.rtp.ulpfec.red_payload_type); + EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type); + EXPECT_EQ(GetEngineCodec("red").id, config.rtp.ulpfec.red_payload_type); EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size()); EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]); @@ -2271,7 +2288,7 @@ TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) { TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); @@ -2283,8 +2300,11 @@ TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) { TEST_F(WebRtcVideoChannel2Test, SetSendCodecRejectsRtxWithoutAssociatedPayloadType) { + const int kUnusedPayloadType = 127; + EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType)); + cricket::VideoSendParameters parameters; - cricket::VideoCodec rtx_codec(96, "rtx"); + cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx"); parameters.codecs.push_back(rtx_codec); EXPECT_FALSE(channel_->SetSendParameters(parameters)) << "RTX codec without associated payload type should be rejected."; @@ -2292,31 +2312,39 @@ TEST_F(WebRtcVideoChannel2Test, TEST_F(WebRtcVideoChannel2Test, SetSendCodecRejectsRtxWithoutMatchingVideoCodec) { - cricket::VideoSendParameters parameters; - cricket::VideoCodec rtx_codec = - cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id); - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(rtx_codec); - ASSERT_TRUE(channel_->SetSendParameters(parameters)); - - cricket::VideoCodec rtx_codec2 = - cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1); - parameters.codecs.pop_back(); - parameters.codecs.push_back(rtx_codec2); - EXPECT_FALSE(channel_->SetSendParameters(parameters)) - << "RTX without matching video codec should be rejected."; + const int kUnusedPayloadType1 = 126; + const int kUnusedPayloadType2 = 127; + EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1)); + EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2)); + { + cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec( + kUnusedPayloadType1, GetEngineCodec("VP8").id); + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(rtx_codec); + ASSERT_TRUE(channel_->SetSendParameters(parameters)); + } + { + cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec( + kUnusedPayloadType1, kUnusedPayloadType2); + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(rtx_codec); + EXPECT_FALSE(channel_->SetSendParameters(parameters)) + << "RTX without matching video codec should be rejected."; + } } TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kUlpfecCodec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("ulpfec")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); - EXPECT_EQ(kUlpfecCodec.id, config.rtp.ulpfec.ulpfec_payload_type); + EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type); parameters.codecs.pop_back(); ASSERT_TRUE(channel_->SetSendParameters(parameters)); @@ -2461,7 +2489,7 @@ TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthAndAddSendStream) { TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); channel_->SetSend(true); @@ -2488,7 +2516,7 @@ TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) { TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(channel_->SetSendParameters(parameters)); channel_->SetSend(true); @@ -2522,7 +2550,7 @@ TEST_F(WebRtcVideoChannel2Test, TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) { static const char* kMaxQuantization = "21"; cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization; EXPECT_TRUE(channel_->SetSendParameters(parameters)); EXPECT_EQ(static_cast(atoi(kMaxQuantization)), @@ -2537,7 +2565,7 @@ TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) { // TODO(pbos): Should we only allow the dynamic range? static const int kIncorrectPayloads[] = {-2, -1, 128, 129}; cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) { parameters.codecs[0].id = kIncorrectPayloads[i]; EXPECT_FALSE(channel_->SetSendParameters(parameters)) @@ -2547,8 +2575,7 @@ TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) { TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); - // Only the dynamic payload types are valid for video codecs. + parameters.codecs.push_back(GetEngineCodec("VP8")); for (int payload_type = 96; payload_type <= 127; ++payload_type) { parameters.codecs[0].id = payload_type; EXPECT_TRUE(channel_->SetSendParameters(parameters)) @@ -2563,42 +2590,47 @@ TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) { TEST_F(WebRtcVideoChannel2Test, SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) { cricket::VideoSendParameters parameters1; - parameters1.codecs.push_back(kVp8Codec); - parameters1.codecs.push_back(kVp9Codec); + parameters1.codecs.push_back(GetEngineCodec("VP8")); + parameters1.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(channel_->SetSendParameters(parameters1)); AddSendStream(); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); cricket::VideoSendParameters parameters2; - parameters2.codecs.push_back(kVp8Codec); + parameters2.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(channel_->SetSendParameters(parameters2)); EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); } TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) { cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(channel_->SetRecvParameters(parameters)); } // Test that we set our inbound RTX codecs properly. TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) { + const int kUnusedPayloadType1 = 126; + const int kUnusedPayloadType2 = 127; + EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1)); + EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2)); + cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); - cricket::VideoCodec rtx_codec(96, "rtx"); + parameters.codecs.push_back(GetEngineCodec("VP8")); + cricket::VideoCodec rtx_codec(kUnusedPayloadType1, "rtx"); parameters.codecs.push_back(rtx_codec); EXPECT_FALSE(channel_->SetRecvParameters(parameters)) << "RTX codec without associated payload should be rejected."; - parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1); + parameters.codecs[1].SetParam("apt", kUnusedPayloadType2); EXPECT_FALSE(channel_->SetRecvParameters(parameters)) << "RTX codec with invalid associated payload type should be rejected."; - parameters.codecs[1].SetParam("apt", kVp8Codec.id); + parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id); EXPECT_TRUE(channel_->SetRecvParameters(parameters)); - cricket::VideoCodec rtx_codec2(97, "rtx"); + cricket::VideoCodec rtx_codec2(kUnusedPayloadType2, "rtx"); rtx_codec2.SetParam("apt", rtx_codec.id); parameters.codecs.push_back(rtx_codec2); @@ -2609,7 +2641,7 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) { TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) { cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[0].id = 99; EXPECT_TRUE(channel_->SetRecvParameters(parameters)); } @@ -2627,7 +2659,7 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) { TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) { cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(VideoCodec(101, "WTF3")); EXPECT_FALSE(channel_->SetRecvParameters(parameters)); } @@ -2636,34 +2668,34 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) { TEST_F(WebRtcVideoChannel2Test, DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) { cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannel2Test, DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) { cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(channel_->SetRecvParameters(parameters)); FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs. } TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) { cricket::VideoSendParameters send_parameters; - send_parameters.codecs.push_back(kVp8Codec); - send_parameters.codecs.push_back(kRedCodec); - send_parameters.codecs.push_back(kUlpfecCodec); + send_parameters.codecs.push_back(GetEngineCodec("VP8")); + send_parameters.codecs.push_back(GetEngineCodec("red")); + send_parameters.codecs.push_back(GetEngineCodec("ulpfec")); ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); FakeVideoReceiveStream* stream = AddRecvStream(); - EXPECT_EQ(kUlpfecCodec.id, + EXPECT_EQ(GetEngineCodec("ulpfec").id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type); cricket::VideoRecvParameters recv_parameters; - recv_parameters.codecs.push_back(kVp8Codec); + recv_parameters.codecs.push_back(GetEngineCodec("VP8")); ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; ASSERT_TRUE(stream != NULL); @@ -2673,41 +2705,43 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) { TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithFecEnablesFec) { FakeVideoReceiveStream* stream = AddRecvStream(); - EXPECT_EQ(kUlpfecCodec.id, + EXPECT_EQ(GetEngineCodec("ulpfec").id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type); cricket::VideoRecvParameters recv_parameters; - recv_parameters.codecs.push_back(kVp8Codec); - recv_parameters.codecs.push_back(kRedCodec); - recv_parameters.codecs.push_back(kUlpfecCodec); + recv_parameters.codecs.push_back(GetEngineCodec("VP8")); + recv_parameters.codecs.push_back(GetEngineCodec("red")); + recv_parameters.codecs.push_back(GetEngineCodec("ulpfec")); ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; ASSERT_TRUE(stream != NULL); - EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) + EXPECT_EQ(GetEngineCodec("ulpfec").id, + stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) << "FEC should be enabled on the receive stream."; cricket::VideoSendParameters send_parameters; - send_parameters.codecs.push_back(kVp8Codec); - send_parameters.codecs.push_back(kRedCodec); - send_parameters.codecs.push_back(kUlpfecCodec); + send_parameters.codecs.push_back(GetEngineCodec("VP8")); + send_parameters.codecs.push_back(GetEngineCodec("red")); + send_parameters.codecs.push_back(GetEngineCodec("ulpfec")); ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); stream = fake_call_->GetVideoReceiveStreams()[0]; - EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) + EXPECT_EQ(GetEngineCodec("ulpfec").id, + stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) << "FEC should be enabled on the receive stream."; } TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) { cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kRedCodec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("red")); parameters.codecs[1].id = parameters.codecs[0].id; EXPECT_FALSE(channel_->SetRecvParameters(parameters)); } TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) { cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP9")); parameters.codecs[1].id = parameters.codecs[0].id; EXPECT_FALSE(channel_->SetRecvParameters(parameters)); } @@ -2715,8 +2749,8 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) { TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) { cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs[1].id += 1; EXPECT_TRUE(channel_->SetRecvParameters(parameters)); } @@ -2726,16 +2760,16 @@ TEST_F(WebRtcVideoChannel2Test, TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentOrderDoesntRecreateStream) { cricket::VideoRecvParameters parameters1; - parameters1.codecs.push_back(kVp8Codec); - parameters1.codecs.push_back(kRedCodec); + parameters1.codecs.push_back(GetEngineCodec("VP8")); + parameters1.codecs.push_back(GetEngineCodec("red")); EXPECT_TRUE(channel_->SetRecvParameters(parameters1)); AddRecvStream(cricket::StreamParams::CreateLegacy(123)); EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); cricket::VideoRecvParameters parameters2; - parameters2.codecs.push_back(kRedCodec); - parameters2.codecs.push_back(kVp8Codec); + parameters2.codecs.push_back(GetEngineCodec("red")); + parameters2.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(channel_->SetRecvParameters(parameters2)); EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); } @@ -2855,14 +2889,14 @@ TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) { TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) { cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(channel_->SetSendParameters(parameters)); AddSendStream(); cricket::VideoMediaInfo info; ASSERT_TRUE(channel_->GetStats(&info)); - EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name); + EXPECT_EQ("VP8", info.senders[0].codec_name); } TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) { @@ -3275,7 +3309,7 @@ TEST_F(WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName) { EXPECT_STREQ("", info.receivers[0].codec_name.c_str()); // Report VP8 if we're receiving it. - stats.current_payload_type = kDefaultVp8PlType; + stats.current_payload_type = GetEngineCodec("VP8").id; stream->SetStats(stats); ASSERT_TRUE(channel_->GetStats(&info)); EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str()); @@ -3287,12 +3321,15 @@ TEST_F(WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName) { EXPECT_STREQ("", info.receivers[0].codec_name.c_str()); } -void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket( +void WebRtcVideoChannel2Test::TestReceiveUnsignaledSsrcPacket( uint8_t payload_type, bool expect_created_receive_stream) { + // kRedRtxPayloadType must currently be unused. + EXPECT_FALSE(FindCodecById(engine_.codecs(), kRedRtxPayloadType)); + // Add a RED RTX codec. VideoCodec red_rtx_codec = - VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType); + VideoCodec::CreateRtxCodec(kRedRtxPayloadType, GetEngineCodec("red").id); recv_parameters_.codecs.push_back(red_rtx_codec); EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); @@ -3319,23 +3356,30 @@ void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket( } TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) { - TestReceiveUnsignalledSsrcPacket(kDefaultVp8PlType, true); + TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP8").id, + true /* expect_created_receive_stream */); } TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) { - TestReceiveUnsignalledSsrcPacket(kDefaultVp9PlType, true); + TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP9").id, + true /* expect_created_receive_stream */); } TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) { - TestReceiveUnsignalledSsrcPacket(kDefaultRtxVp8PlType, false); + const cricket::VideoCodec vp8 = GetEngineCodec("VP8"); + const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id]; + TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type, + false /* expect_created_receive_stream */); } TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) { - TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false); + TestReceiveUnsignaledSsrcPacket(GetEngineCodec("ulpfec").id, + false /* expect_created_receive_stream */); } TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) { - TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false); + TestReceiveUnsignaledSsrcPacket(kRedRtxPayloadType, + false /* expect_created_receive_stream */); } TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) { @@ -3430,8 +3474,8 @@ TEST_F(WebRtcVideoChannel2Test, InactiveStreamDoesntStartSendingWhenReconfigured) { // Set an initial codec list, which will be modified later. cricket::VideoSendParameters parameters1; - parameters1.codecs.push_back(kVp8Codec); - parameters1.codecs.push_back(kVp9Codec); + parameters1.codecs.push_back(GetEngineCodec("VP8")); + parameters1.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(channel_->SetSendParameters(parameters1)); FakeVideoSendStream* stream = AddSendStream(); @@ -3450,8 +3494,8 @@ TEST_F(WebRtcVideoChannel2Test, // Reorder the codec list, causing the stream to be reconfigured. cricket::VideoSendParameters parameters2; - parameters2.codecs.push_back(kVp9Codec); - parameters2.codecs.push_back(kVp8Codec); + parameters2.codecs.push_back(GetEngineCodec("VP9")); + parameters2.codecs.push_back(GetEngineCodec("VP8")); EXPECT_TRUE(channel_->SetSendParameters(parameters2)); auto new_streams = GetFakeSendStreams(); // Assert that a new underlying stream was created due to the codec change. @@ -3468,23 +3512,25 @@ TEST_F(WebRtcVideoChannel2Test, TEST_F(WebRtcVideoChannel2Test, GetRtpSendParametersCodecs) { AddSendStream(); cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(channel_->SetSendParameters(parameters)); webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(last_ssrc_); ASSERT_EQ(2u, rtp_parameters.codecs.size()); - EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]); - EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]); + EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(), + rtp_parameters.codecs[0]); + EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(), + rtp_parameters.codecs[1]); } // Test that if we set/get parameters multiple times, we get the same results. TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) { AddSendStream(); cricket::VideoSendParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(channel_->SetSendParameters(parameters)); webrtc::RtpParameters initial_params = @@ -3501,15 +3547,17 @@ TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) { TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs) { AddRecvStream(); cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(channel_->SetRecvParameters(parameters)); webrtc::RtpParameters rtp_parameters = channel_->GetRtpReceiveParameters(last_ssrc_); ASSERT_EQ(2u, rtp_parameters.codecs.size()); - EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]); - EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]); + EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(), + rtp_parameters.codecs[0]); + EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(), + rtp_parameters.codecs[1]); } #if defined(WEBRTC_USE_H264) @@ -3566,8 +3614,8 @@ TEST_F(WebRtcVideoChannel2Test, RtpEncodingParametersSsrcIsSet) { TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters) { AddRecvStream(); cricket::VideoRecvParameters parameters; - parameters.codecs.push_back(kVp8Codec); - parameters.codecs.push_back(kVp9Codec); + parameters.codecs.push_back(GetEngineCodec("VP8")); + parameters.codecs.push_back(GetEngineCodec("VP9")); EXPECT_TRUE(channel_->SetRecvParameters(parameters)); webrtc::RtpParameters initial_params = @@ -3761,16 +3809,15 @@ class WebRtcVideoChannel2SimulcastTest : public testing::Test { }; TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { - VerifySimulcastSettings(kVp8Codec, 640, 360, 2, 2); + VerifySimulcastSettings(cricket::VideoCodec("VP8"), 640, 360, 2, 2); } TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { - VerifySimulcastSettings(kVp8Codec, 1280, 720, 3, 3); + VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3); } // Test that we normalize send codec format size in simulcast. TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) { - cricket::VideoCodec codec(kVp8Codec); - VerifySimulcastSettings(codec, 541, 271, 2, 2); + VerifySimulcastSettings(cricket::VideoCodec("VP8"), 541, 271, 2, 2); } } // namespace cricket diff --git a/webrtc/video/BUILD.gn b/webrtc/video/BUILD.gn index 7b6dd8f8e7..5f9f75c1ef 100644 --- a/webrtc/video/BUILD.gn +++ b/webrtc/video/BUILD.gn @@ -37,7 +37,6 @@ rtc_static_library("video") { "transport_adapter.cc", "transport_adapter.h", "video_decoder.cc", - "video_encoder.cc", "video_receive_stream.cc", "video_receive_stream.h", "video_send_stream.cc", diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc index 3ff3bd23f5..d93dd247d1 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -353,23 +353,20 @@ class CodecObserver : public test::EndToEndTest, }; TEST_F(EndToEndTest, SendsAndReceivesVP8Rotation90) { - CodecObserver test(5, kVideoRotation_90, "VP8", - VideoEncoder::Create(VideoEncoder::kVp8), + CodecObserver test(5, kVideoRotation_90, "VP8", VP8Encoder::Create(), VP8Decoder::Create()); RunBaseTest(&test); } #if !defined(RTC_DISABLE_VP9) TEST_F(EndToEndTest, SendsAndReceivesVP9) { - CodecObserver test(500, kVideoRotation_0, "VP9", - VideoEncoder::Create(VideoEncoder::kVp9), + CodecObserver test(500, kVideoRotation_0, "VP9", VP9Encoder::Create(), VP9Decoder::Create()); RunBaseTest(&test); } TEST_F(EndToEndTest, SendsAndReceivesVP9VideoRotation90) { - CodecObserver test(5, kVideoRotation_90, "VP9", - VideoEncoder::Create(VideoEncoder::kVp9), + CodecObserver test(5, kVideoRotation_90, "VP9", VP9Encoder::Create(), VP9Decoder::Create()); RunBaseTest(&test); } @@ -377,15 +374,13 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9VideoRotation90) { #if defined(WEBRTC_USE_H264) TEST_F(EndToEndTest, SendsAndReceivesH264) { - CodecObserver test(500, kVideoRotation_0, "H264", - VideoEncoder::Create(VideoEncoder::kH264), + CodecObserver test(500, kVideoRotation_0, "H264", H264Encoder::Create(), H264Decoder::Create()); RunBaseTest(&test); } TEST_F(EndToEndTest, SendsAndReceivesH264VideoRotation90) { - CodecObserver test(5, kVideoRotation_90, "H264", - VideoEncoder::Create(VideoEncoder::kH264), + CodecObserver test(5, kVideoRotation_90, "H264", H264Encoder::Create(), H264Decoder::Create()); RunBaseTest(&test); } @@ -765,7 +760,7 @@ TEST_F(EndToEndTest, ReceivedUlpfecPacketsNotNacked) { ulpfec_sequence_number_(0), has_last_sequence_number_(false), last_sequence_number_(0), - encoder_(VideoEncoder::Create(VideoEncoder::EncoderType::kVp8)), + encoder_(VP8Encoder::Create()), decoder_(VP8Decoder::Create()) {} private: @@ -933,7 +928,7 @@ void EndToEndTest::DecodesRetransmittedFrame(bool enable_rtx, bool enable_red) { retransmission_ssrc_(enable_rtx ? kSendRtxSsrcs[0] : kVideoSendSsrcs[0]), retransmission_payload_type_(GetPayloadType(enable_rtx, enable_red)), - encoder_(VideoEncoder::Create(VideoEncoder::EncoderType::kVp8)), + encoder_(VP8Encoder::Create()), marker_bits_observed_(0), retransmitted_timestamp_(0) {} @@ -1332,7 +1327,7 @@ class MultiStreamTest { std::unique_ptr encoders[kNumStreams]; for (size_t i = 0; i < kNumStreams; ++i) - encoders[i].reset(VideoEncoder::Create(VideoEncoder::kVp8)); + encoders[i].reset(VP8Encoder::Create()); VideoSendStream* send_streams[kNumStreams]; VideoReceiveStream* receive_streams[kNumStreams]; @@ -2182,9 +2177,7 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, use_red_(use_red), screenshare_(screenshare), // This test uses NACK, so to send FEC we can't use a fake encoder. - vp8_encoder_( - use_red ? VideoEncoder::Create(VideoEncoder::EncoderType::kVp8) - : nullptr), + vp8_encoder_(use_red ? VP8Encoder::Create() : nullptr), sender_call_(nullptr), receiver_call_(nullptr), start_runtime_ms_(-1), @@ -3975,7 +3968,7 @@ TEST_F(EndToEndLogTest, LogsEncodedFramesWhenRequested) { VideoSendStream::Config* send_config, std::vector* receive_configs, VideoEncoderConfig* encoder_config) override { - encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp8)); + encoder_.reset(VP8Encoder::Create()); decoder_.reset(VP8Decoder::Create()); send_config->post_encode_callback = this; diff --git a/webrtc/video/video_encoder.cc b/webrtc/video/video_encoder.cc deleted file mode 100644 index f4e8156528..0000000000 --- a/webrtc/video/video_encoder.cc +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (c) 2015 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 "webrtc/video_encoder.h" - -#include "webrtc/base/checks.h" -#include "webrtc/base/logging.h" -#include "webrtc/modules/video_coding/codecs/h264/include/h264.h" -#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" -#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" - -namespace webrtc { -VideoEncoder* VideoEncoder::Create(VideoEncoder::EncoderType codec_type) { - RTC_DCHECK(IsSupportedSoftware(codec_type)); - switch (codec_type) { - case kH264: - return H264Encoder::Create(); - case kVp8: - return VP8Encoder::Create(); - case kVp9: - return VP9Encoder::Create(); - case kUnsupportedCodec: - RTC_NOTREACHED(); - return nullptr; - } - RTC_NOTREACHED(); - return nullptr; -} - -bool VideoEncoder::IsSupportedSoftware(EncoderType codec_type) { - switch (codec_type) { - case kH264: - return H264Encoder::IsSupported(); - case kVp8: - return true; - case kVp9: - return VP9Encoder::IsSupported(); - case kUnsupportedCodec: - RTC_NOTREACHED(); - return false; - } - RTC_NOTREACHED(); - return false; -} - -VideoEncoder::EncoderType VideoEncoder::CodecToEncoderType( - VideoCodecType codec_type) { - switch (codec_type) { - case kVideoCodecH264: - return VideoEncoder::kH264; - case kVideoCodecVP8: - return VideoEncoder::kVp8; - case kVideoCodecVP9: - return VideoEncoder::kVp9; - default: - return VideoEncoder::kUnsupportedCodec; - } -} - -} // namespace webrtc diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc index d0624c0a52..42f24046b2 100644 --- a/webrtc/video/video_quality_test.cc +++ b/webrtc/video/video_quality_test.cc @@ -29,6 +29,9 @@ #include "webrtc/modules/audio_mixer/audio_mixer_impl.h" #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" +#include "webrtc/modules/video_coding/codecs/h264/include/h264.h" +#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" +#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" #include "webrtc/system_wrappers/include/cpu_info.h" #include "webrtc/test/gtest.h" #include "webrtc/test/layer_filtering_transport.h" @@ -1006,13 +1009,13 @@ void VideoQualityTest::SetupVideo(Transport* send_transport, int payload_type; if (params_.video.codec == "H264") { - video_encoder_.reset(VideoEncoder::Create(VideoEncoder::kH264)); + video_encoder_.reset(H264Encoder::Create()); payload_type = kPayloadTypeH264; } else if (params_.video.codec == "VP8") { - video_encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp8)); + video_encoder_.reset(VP8Encoder::Create()); payload_type = kPayloadTypeVP8; } else if (params_.video.codec == "VP9") { - video_encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp9)); + video_encoder_.reset(VP9Encoder::Create()); payload_type = kPayloadTypeVP9; } else { RTC_NOTREACHED() << "Codec not supported!"; diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc index c9d8f76549..cc76b13515 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -24,6 +24,7 @@ #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h" #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h" +#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" #include "webrtc/system_wrappers/include/sleep.h" #include "webrtc/test/call_test.h" @@ -367,9 +368,9 @@ class UlpfecObserver : public test::EndToEndTest { if (codec == "H264") { encoder_.reset(new test::FakeH264Encoder(Clock::GetRealTimeClock())); } else if (codec == "VP8") { - encoder_.reset(VideoEncoder::Create(VideoEncoder::EncoderType::kVp8)); + encoder_.reset(VP8Encoder::Create()); } else if (codec == "VP9") { - encoder_.reset(VideoEncoder::Create(VideoEncoder::EncoderType::kVp9)); + encoder_.reset(VP9Encoder::Create()); } else { RTC_NOTREACHED(); } @@ -552,9 +553,9 @@ class FlexfecObserver : public test::EndToEndTest { if (codec == "H264") { encoder_.reset(new test::FakeH264Encoder(Clock::GetRealTimeClock())); } else if (codec == "VP8") { - encoder_.reset(VideoEncoder::Create(VideoEncoder::EncoderType::kVp8)); + encoder_.reset(VP8Encoder::Create()); } else if (codec == "VP9") { - encoder_.reset(VideoEncoder::Create(VideoEncoder::EncoderType::kVp9)); + encoder_.reset(VP9Encoder::Create()); } else { RTC_NOTREACHED(); } diff --git a/webrtc/video_encoder.h b/webrtc/video_encoder.h index 3a997176a9..f8a04f2e74 100644 --- a/webrtc/video_encoder.h +++ b/webrtc/video_encoder.h @@ -63,19 +63,6 @@ class EncodedImageCallback { class VideoEncoder { public: - enum EncoderType { - kH264, - kVp8, - kVp9, - kUnsupportedCodec, - }; - - static VideoEncoder* Create(EncoderType codec_type); - // Returns true if this type of encoder can be created using - // VideoEncoder::Create. - static bool IsSupportedSoftware(EncoderType codec_type); - static EncoderType CodecToEncoderType(VideoCodecType codec_type); - static VideoCodecVP8 GetDefaultVp8Settings(); static VideoCodecVP9 GetDefaultVp9Settings(); static VideoCodecH264 GetDefaultH264Settings();