ffmpeg/tools: Actually use the score

Correctly sets all color settings for the context and frames, which should result in better playback in players that support these. Unfortunately it does not fix the bug that VLC and MPC-HC incorrectly assume that the ProRes encoded content is in Partial range, however most editing software does correctly detect it.

source/encoder.cpp

@@ -632,25 +632,23 @@ obsffmpeg::encoder::encoder(obs_data_t* settings, obs_encoder_t* encoder, bool i
 			}
 		}
 
-		_context->width                   = voi->width;
-		_context->height                  = voi->height;
-		_context->colorspace              = ffmpeg::tools::obs_videocolorspace_to_avcolorspace(voi->colorspace);
-		_context->color_range             = ffmpeg::tools::obs_videorangetype_to_avcolorrange(voi->range);
+		_context->width  = voi->width;
+		_context->height = voi->height;
+		ffmpeg::tools::setup_obs_color(voi->colorspace, voi->range, _context);
+
 		_context->pix_fmt                 = _pixfmt_target;
 		_context->field_order             = AV_FIELD_PROGRESSIVE;
-		_context->time_base.num           = voi->fps_den;
-		_context->time_base.den           = voi->fps_num;
 		_context->ticks_per_frame         = 1;
 		_context->sample_aspect_ratio.num = _context->sample_aspect_ratio.den = 1;
+		_context->framerate.num = _context->time_base.den = voi->fps_num;
+		_context->framerate.den = _context->time_base.num = voi->fps_den;
 
 		_swscale.set_source_size(_context->width, _context->height);
-		_swscale.set_source_color(_context->color_range, _context->colorspace);
-		_swscale.set_source_full_range(voi->range == VIDEO_RANGE_FULL);
+		_swscale.set_source_color(_context->color_range == AVCOL_RANGE_JPEG, _context->colorspace);
 		_swscale.set_source_format(_pixfmt_source);
 
 		_swscale.set_target_size(_context->width, _context->height);
-		_swscale.set_target_color(_context->color_range, _context->colorspace);
-		_swscale.set_target_full_range(voi->range == VIDEO_RANGE_FULL);
+		_swscale.set_target_color(_context->color_range == AVCOL_RANGE_JPEG, _context->colorspace);
 		_swscale.set_target_format(_pixfmt_target);
 
 		// Create Scaler
@@ -667,20 +665,23 @@ obsffmpeg::encoder::encoder(obs_data_t* settings, obs_encoder_t* encoder, bool i
 	}
 
 	{ // Log Encoder info
-		const char* id = obs_encoder_get_id(_self);
-		PLOG_INFO("[%s] Initializing...", id);
-		PLOG_INFO("[%s]   Video Input: %ldx%ld %s %s %s", id, _swscale.get_source_width(),
+		PLOG_INFO("[%s] Initializing...", _codec->name);
+		PLOG_INFO("[%s]   Video Input: %ldx%ld %s %s %s", _codec->name, _swscale.get_source_width(),
 		          _swscale.get_source_height(),
 		          ffmpeg::tools::get_pixel_format_name(_swscale.get_source_format()),
 		          ffmpeg::tools::get_color_space_name(_swscale.get_source_colorspace()),
 		          _swscale.is_source_full_range() ? "Full" : "Partial");
-		PLOG_INFO("[%s]   Video Output: %ldx%ld %s %s %s", id, _swscale.get_target_width(),
+		PLOG_INFO("[%s]   Video Output: %ldx%ld %s %s %s", _codec->name, _swscale.get_target_width(),
 		          _swscale.get_target_height(),
 		          ffmpeg::tools::get_pixel_format_name(_swscale.get_target_format()),
 		          ffmpeg::tools::get_color_space_name(_swscale.get_target_colorspace()),
 		          _swscale.is_target_full_range() ? "Full" : "Partial");
-		PLOG_INFO("[%s]   Framerate: %ld/%ld (%f", id, _context->time_base.num, _context->time_base.den,
-		          _context->time_base.num / _context->time_base.den);
+		PLOG_INFO("[%s]   Framerate: %ld/%ld (%f FPS)", _codec->name, _context->time_base.den,
+		          _context->time_base.num,
+		          static_cast<double_t>(_context->time_base.den)
+		              / static_cast<double_t>(_context->time_base.num));
+		PLOG_INFO("[%s]   Custom Settings: %s", _codec->name,
+		          obs_data_get_string(settings, ST_FFMPEG_CUSTOMSETTINGS));
 	}
 
 	// Update settings
@@ -866,11 +867,13 @@ bool obsffmpeg::encoder::video_encode(encoder_frame* frame, encoder_packet* pack
 		ScopeProfiler profile("convert");
 #endif
 
-		vframe->height      = _context->height;
-		vframe->format      = _context->pix_fmt;
-		vframe->color_range = _context->color_range;
-		vframe->colorspace  = _context->colorspace;
-		vframe->pts         = frame->pts;
+		vframe->height          = _context->height;
+		vframe->format          = _context->pix_fmt;
+		vframe->color_range     = _context->color_range;
+		vframe->colorspace      = _context->colorspace;
+		vframe->color_primaries = _context->color_primaries;
+		vframe->color_trc       = _context->color_trc;
+		vframe->pts             = frame->pts;
 
 		if ((_swscale.is_source_full_range() == _swscale.is_target_full_range())
 		    && (_swscale.get_source_colorspace() == _swscale.get_target_colorspace())
@@ -1016,6 +1019,9 @@ int obsffmpeg::encoder::receive_packet(bool* received_packet, struct encoder_pac
 			} else if (_codec->id == AV_CODEC_ID_HEVC) {
 				obsffmpeg::codecs::hevc::extract_header_sei(_current_packet.data, _current_packet.size,
 				                                            _extra_data, _sei_data);
+			} else if (_context->extradata != nullptr) {
+				_extra_data.resize(_context->extradata_size);
+				std::memcpy(_extra_data.data(), _context->extradata, _context->extradata_size);
 			}
 			_have_first_frame = true;
 		}

source/ffmpeg/tools.cpp

@@ -220,10 +220,10 @@ AVColorRange ffmpeg::tools::obs_videorangetype_to_avcolorrange(video_range_type
 {
 	switch (v) {
 	case VIDEO_RANGE_DEFAULT:
-	case VIDEO_RANGE_FULL:
-		return AVCOL_RANGE_JPEG;
 	case VIDEO_RANGE_PARTIAL:
 		return AVCOL_RANGE_MPEG;
+	case VIDEO_RANGE_FULL:
+		return AVCOL_RANGE_JPEG;
 	}
 	throw std::invalid_argument("unknown range");
 }
@@ -365,7 +365,7 @@ AVPixelFormat ffmpeg::tools::get_best_compatible_format(const AVPixelFormat* lis
 
 	for (auto fmt = list; fmt && (*fmt != AV_PIX_FMT_NONE); fmt++) {
 		auto found = format_compatibility.find(std::pair{source, *fmt});
-		if (found != format_compatibility.end()) {
+		if (found != format_compatibility.end() && (score < found->second)) {
 			score = found->second;
 			best  = *fmt;
 		}
@@ -378,3 +378,36 @@ AVPixelFormat ffmpeg::tools::get_best_compatible_format(const AVPixelFormat* lis
 
 	return best;
 }
+
+void ffmpeg::tools::setup_obs_color(video_colorspace colorspace, video_range_type range, AVCodecContext* context)
+{
+	std::map<video_colorspace, std::tuple<AVColorSpace, AVColorPrimaries, AVColorTransferCharacteristic>>
+	    colorspaces = {
+	        {VIDEO_CS_DEFAULT, {AVCOL_SPC_BT470BG, AVCOL_PRI_BT470BG, AVCOL_TRC_SMPTE170M}},
+	        {VIDEO_CS_601, {AVCOL_SPC_BT470BG, AVCOL_PRI_BT470BG, AVCOL_TRC_SMPTE170M}},
+	        {VIDEO_CS_709, {AVCOL_SPC_BT709, AVCOL_PRI_BT709, AVCOL_TRC_BT709}},
+	    };
+	std::map<video_range_type, AVColorRange> colorranges = {
+	    {VIDEO_RANGE_DEFAULT, AVCOL_RANGE_MPEG},
+	    {VIDEO_RANGE_PARTIAL, AVCOL_RANGE_MPEG},
+	    {VIDEO_RANGE_FULL, AVCOL_RANGE_JPEG},
+	};
+
+	{
+		auto found = colorspaces.find(colorspace);
+		if (found != colorspaces.end()) {
+			context->colorspace      = std::get<AVColorSpace>(found->second);
+			context->color_primaries = std::get<AVColorPrimaries>(found->second);
+			context->color_trc       = std::get<AVColorTransferCharacteristic>(found->second);
+		}
+	}
+	{
+		auto found = colorranges.find(range);
+		if (found != colorranges.end()) {
+			context->color_range = found->second;
+		}
+	}
+
+	// Downscaling should result in downscaling, not pixelation
+	context->chroma_sample_location = AVCHROMA_LOC_CENTER; 
+}

source/ffmpeg/tools.hpp

@@ -28,8 +28,8 @@
 #include <vector>
 
 extern "C" {
-#include <libavutil/pixfmt.h>
 #include <libavcodec/avcodec.h>
+#include <libavutil/pixfmt.h>
 }
 
 namespace ffmpeg {
@@ -57,6 +57,8 @@ namespace ffmpeg {
 		std::vector<AVPixelFormat> get_software_formats(const AVPixelFormat* list);
 
 		AVPixelFormat get_best_compatible_format(const AVPixelFormat* list, AVPixelFormat source);
+
+		void setup_obs_color(video_colorspace colorspace, video_range_type range, AVCodecContext* context);
 	} // namespace tools
 } // namespace ffmpeg
 

source/ui/handler.cpp

@@ -29,6 +29,12 @@ void obsffmpeg::ui::handler::override_colorformat(AVPixelFormat& target_format,
                                                   const AVCodec* codec, AVCodecContext* context)
 {}
 
+void obsffmpeg::ui::handler::get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context) {}
+
+void obsffmpeg::ui::handler::get_properties(obs_properties_t* props, const AVCodec* codec, AVCodecContext* context) {}
+
+void obsffmpeg::ui::handler::update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context) {}
+
 void obsffmpeg::ui::handler::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context) {}
 
 void obsffmpeg::ui::handler::import_from_ffmpeg(const std::string ffmpeg, obs_data_t* settings, const AVCodec* codec,

source/ui/handler.hpp

@@ -46,13 +46,12 @@ namespace obsffmpeg {
 			virtual void override_colorformat(AVPixelFormat& target_format, obs_data_t* settings,
 			                                  const AVCodec* codec, AVCodecContext* context);
 
-			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec,
-			                          AVCodecContext* context) = 0;
+			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
 			virtual void get_properties(obs_properties_t* props, const AVCodec* codec,
-			                            AVCodecContext* context) = 0;
+			                            AVCodecContext* context);
 
-			virtual void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context) = 0;
+			virtual void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
 			virtual void log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 

source/ui/nvenc_h264_handler.cpp

@@ -57,6 +57,7 @@ Useless except for strict_gop maybe?
 */
 
 using namespace obsffmpeg::codecs::h264;
+using namespace obsffmpeg::nvenc;
 
 std::map<profile, std::string> profiles{
     {profile::BASELINE, "baseline"},
@@ -125,6 +126,22 @@ void obsffmpeg::ui::nvenc_h264_handler::update(obs_data_t* settings, const AVCod
 	}
 }
 
+void obsffmpeg::ui::nvenc_h264_handler::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
+{
+	nvenc::log_options(settings, codec, context);
+
+	profile cfg_profile = static_cast<profile>(obs_data_get_int(settings, P_H264_PROFILE));
+	level   cfg_level   = static_cast<level>(obs_data_get_int(settings, P_H264_LEVEL));
+
+	auto found1 = profiles.find(cfg_profile);
+	if (found1 != profiles.end())
+		PLOG_INFO("[%s]   H.264 Profile: %s", codec->name, found1->second.c_str());
+
+	auto found2 = levels.find(cfg_level);
+	if (found2 != levels.end())
+		PLOG_INFO("[%s]   H.264 Level: %s", codec->name, found2->second.c_str());
+}
+
 void obsffmpeg::ui::nvenc_h264_handler::get_encoder_properties(obs_properties_t* props, const AVCodec* codec)
 {
 	nvenc::get_properties_pre(props, codec);

source/ui/nvenc_h264_handler.hpp

@@ -45,6 +45,9 @@ namespace obsffmpeg {
 			virtual void update(obs_data_t* settings, const AVCodec* codec,
 			                    AVCodecContext* context) override;
 
+			virtual void log_options(obs_data_t* settings, const AVCodec* codec,
+			                         AVCodecContext* context) override;
+
 			private:
 			void get_encoder_properties(obs_properties_t* props, const AVCodec* codec);
 

source/ui/nvenc_hevc_handler.cpp

@@ -133,6 +133,27 @@ void obsffmpeg::ui::nvenc_hevc_handler::update(obs_data_t* settings, const AVCod
 	}
 }
 
+void obsffmpeg::ui::nvenc_hevc_handler::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
+{
+	nvenc::log_options(settings, codec, context);
+
+	profile cfg_profile = static_cast<profile>(obs_data_get_int(settings, P_HEVC_PROFILE));
+	tier    cfg_tier    = static_cast<tier>(obs_data_get_int(settings, P_HEVC_TIER));
+	level   cfg_level   = static_cast<level>(obs_data_get_int(settings, P_HEVC_LEVEL));
+
+	auto found1 = profiles.find(cfg_profile);
+	if (found1 != profiles.end())
+		PLOG_INFO("[%s]   H.265 Profile: %s", codec->name, found1->second.c_str());
+
+	auto found2 = levels.find(cfg_level);
+	if (found2 != levels.end())
+		PLOG_INFO("[%s]   H.265 Level: %s", codec->name, found2->second.c_str());
+
+	auto found3 = tiers.find(cfg_tier);
+	if (found3 != tiers.end())
+		PLOG_INFO("[%s]   H.265 Tier: %s", codec->name, found3->second.c_str());
+}
+
 void obsffmpeg::ui::nvenc_hevc_handler::get_encoder_properties(obs_properties_t* props, const AVCodec* codec)
 {
 	nvenc::get_properties_pre(props, codec);

source/ui/nvenc_hevc_handler.hpp

@@ -45,6 +45,9 @@ namespace obsffmpeg {
 			virtual void update(obs_data_t* settings, const AVCodec* codec,
 			                    AVCodecContext* context) override;
 
+			virtual void log_options(obs_data_t* settings, const AVCodec* codec,
+			                         AVCodecContext* context) override;
+
 			private:
 			void get_encoder_properties(obs_properties_t* props, const AVCodec* codec);
 

source/ui/nvenc_shared.cpp

@@ -57,7 +57,7 @@ extern "C" {
 #define ST_RATECONTROL_QP_I ST_RATECONTROL_QP ".I"
 #define ST_RATECONTROL_QP_I_INITIAL ST_RATECONTROL_QP_I ".Initial"
 #define ST_RATECONTROL_QP_P ST_RATECONTROL_QP ".P"
-#define ST_RATECONTROL_QP_ST_INITIAL ST_RATECONTROL_QP_P ".Initial"
+#define ST_RATECONTROL_QP_P_INITIAL ST_RATECONTROL_QP_P ".Initial"
 #define ST_RATECONTROL_QP_B ST_RATECONTROL_QP ".B"
 #define ST_RATECONTROL_QP_B_INITIAL ST_RATECONTROL_QP_B ".Initial"
 
@@ -152,7 +152,7 @@ void obsffmpeg::nvenc::get_defaults(obs_data_t* settings, const AVCodec*, AVCode
 	obs_data_set_default_int(settings, ST_RATECONTROL_QP_I, 21);
 	obs_data_set_default_int(settings, ST_RATECONTROL_QP_I_INITIAL, -1);
 	obs_data_set_default_int(settings, ST_RATECONTROL_QP_P, 21);
-	obs_data_set_default_int(settings, ST_RATECONTROL_QP_ST_INITIAL, -1);
+	obs_data_set_default_int(settings, ST_RATECONTROL_QP_P_INITIAL, -1);
 	obs_data_set_default_int(settings, ST_RATECONTROL_QP_B, 21);
 	obs_data_set_default_int(settings, ST_RATECONTROL_QP_B_INITIAL, -1);
 
@@ -211,7 +211,7 @@ static bool modified_ratecontrol(obs_properties_t* props, obs_property_t*, obs_d
 	obs_property_set_visible(obs_properties_get(props, ST_RATECONTROL_QP_P), have_qp);
 	obs_property_set_visible(obs_properties_get(props, ST_RATECONTROL_QP_B), have_qp);
 	obs_property_set_visible(obs_properties_get(props, ST_RATECONTROL_QP_I_INITIAL), have_qp_init);
-	obs_property_set_visible(obs_properties_get(props, ST_RATECONTROL_QP_ST_INITIAL), have_qp_init);
+	obs_property_set_visible(obs_properties_get(props, ST_RATECONTROL_QP_P_INITIAL), have_qp_init);
 	obs_property_set_visible(obs_properties_get(props, ST_RATECONTROL_QP_B_INITIAL), have_qp_init);
 
 	return true;
@@ -379,9 +379,9 @@ void obsffmpeg::nvenc::get_properties_post(obs_properties_t* props, const AVCode
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_RATECONTROL_QP_P)));
 		}
 		{
-			auto p = obs_properties_add_int_slider(grp, ST_RATECONTROL_QP_ST_INITIAL,
-			                                       TRANSLATE(ST_RATECONTROL_QP_ST_INITIAL), -1, 51, 1);
-			obs_property_set_long_description(p, TRANSLATE(DESC(ST_RATECONTROL_QP_ST_INITIAL)));
+			auto p = obs_properties_add_int_slider(grp, ST_RATECONTROL_QP_P_INITIAL,
+			                                       TRANSLATE(ST_RATECONTROL_QP_P_INITIAL), -1, 51, 1);
+			obs_property_set_long_description(p, TRANSLATE(DESC(ST_RATECONTROL_QP_P_INITIAL)));
 		}
 		{
 			auto p = obs_properties_add_int_slider(grp, ST_RATECONTROL_QP_B, TRANSLATE(ST_RATECONTROL_QP_B),
@@ -483,7 +483,7 @@ void obsffmpeg::nvenc::get_runtime_properties(obs_properties_t* props, const AVC
 	obs_property_set_enabled(obs_properties_get(props, ST_RATECONTROL_QP_I), false);
 	obs_property_set_enabled(obs_properties_get(props, ST_RATECONTROL_QP_I_INITIAL), false);
 	obs_property_set_enabled(obs_properties_get(props, ST_RATECONTROL_QP_P), false);
-	obs_property_set_enabled(obs_properties_get(props, ST_RATECONTROL_QP_ST_INITIAL), false);
+	obs_property_set_enabled(obs_properties_get(props, ST_RATECONTROL_QP_P_INITIAL), false);
 	obs_property_set_enabled(obs_properties_get(props, ST_RATECONTROL_QP_B), false);
 	obs_property_set_enabled(obs_properties_get(props, ST_RATECONTROL_QP_B_INITIAL), false);
 	obs_property_set_enabled(obs_properties_get(props, ST_AQ), false);
@@ -597,7 +597,7 @@ void obsffmpeg::nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCode
 			av_opt_set_int(context->priv_data, "init_qpI",
 			               obs_data_get_int(settings, ST_RATECONTROL_QP_I_INITIAL), 0);
 			av_opt_set_int(context->priv_data, "init_qpP",
-			               obs_data_get_int(settings, ST_RATECONTROL_QP_ST_INITIAL), 0);
+			               obs_data_get_int(settings, ST_RATECONTROL_QP_P_INITIAL), 0);
 			av_opt_set_int(context->priv_data, "init_qpB",
 			               obs_data_get_int(settings, ST_RATECONTROL_QP_B_INITIAL), 0);
 		}
@@ -646,3 +646,113 @@ void obsffmpeg::nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCode
 		}
 	}
 }
+
+void obsffmpeg::nvenc::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
+{
+	preset cfg_preset = static_cast<preset>(obs_data_get_int(settings, ST_PRESET));
+
+	auto found1 = preset_to_opt.find(cfg_preset);
+	if (found1 != preset_to_opt.end())
+		PLOG_INFO("[%s]   Preset: %s", codec->name, found1->second.c_str());
+
+	ratecontrolmode cfg_rc_mode   = static_cast<ratecontrolmode>(obs_data_get_int(settings, ST_RATECONTROL_MODE));
+	int64_t         cfg_rc_2pass  = obs_data_get_int(settings, ST_RATECONTROL_TWOPASS);
+	int64_t         cfg_rc_lahead = obs_data_get_int(settings, ST_RATECONTROL_LOOKAHEAD);
+	bool            cfg_rc_adapti = obs_data_get_bool(settings, ST_RATECONTROL_ADAPTIVEI);
+	bool            cfg_rc_adaptb = obs_data_get_bool(settings, ST_RATECONTROL_ADAPTIVEB);
+
+	auto found2 = ratecontrolmode_to_opt.find(cfg_rc_mode);
+	if (found2 != ratecontrolmode_to_opt.end())
+		PLOG_INFO("[%s]   Rate Control: %s", codec->name, found2->second.c_str());
+	PLOG_INFO("[%s]     Two Pass: %s", codec->name,
+	          cfg_rc_2pass == 1 ? "Enabled" : (cfg_rc_2pass == 0 ? "Disabled" : "Default"));
+	PLOG_INFO("[%s]     Lookahead: %" PRId64 " Frames", codec->name, cfg_rc_lahead);
+	if (cfg_rc_adapti && cfg_rc_lahead > 0)
+		PLOG_INFO("[%s]       Adaptive I-Frames Enabled", codec->name);
+	if (cfg_rc_adaptb && cfg_rc_lahead > 0)
+		PLOG_INFO("[%s]       Adaptive B-Frames Enabled", codec->name);
+
+	int64_t  cfg_rc_bitrate     = obs_data_get_int(settings, ST_RATECONTROL_BITRATE_TARGET);
+	int64_t  cfg_rc_max_bitrate = obs_data_get_int(settings, ST_RATECONTROL_BITRATE_MAXIMUM);
+	int64_t  cfg_rc_bufsize     = obs_data_get_int(settings, S_RATECONTROL_BUFFERSIZE);
+	bool     cfg_rc_quality     = obs_data_get_bool(settings, ST_RATECONTROL_QUALITY);
+	int64_t  cfg_rc_quality_min = obs_data_get_int(settings, ST_RATECONTROL_QUALITY_MINIMUM);
+	int64_t  cfg_rc_quality_max = obs_data_get_int(settings, ST_RATECONTROL_QUALITY_MAXIMUM);
+	double_t cfg_rc_quality_tgt = obs_data_get_int(settings, ST_RATECONTROL_QUALITY_TARGET);
+	int64_t  cfg_rc_qp_i        = obs_data_get_int(settings, ST_RATECONTROL_QP_I);
+	int64_t  cfg_rc_qp_p        = obs_data_get_int(settings, ST_RATECONTROL_QP_P);
+	int64_t  cfg_rc_qp_b        = obs_data_get_int(settings, ST_RATECONTROL_QP_B);
+	int64_t  cfg_rc_qp_i_init   = obs_data_get_int(settings, ST_RATECONTROL_QP_I_INITIAL);
+	int64_t  cfg_rc_qp_p_init   = obs_data_get_int(settings, ST_RATECONTROL_QP_P_INITIAL);
+	int64_t  cfg_rc_qp_b_init   = obs_data_get_int(settings, ST_RATECONTROL_QP_B_INITIAL);
+
+	{
+		bool have_bitrate     = false;
+		bool have_bitrate_max = false;
+		bool have_quality     = false;
+		bool have_qp          = false;
+		bool have_qp_init     = false;
+
+		switch (cfg_rc_mode) {
+		case ratecontrolmode::CQP:
+			have_qp = true;
+			break;
+		case ratecontrolmode::CBR:
+		case ratecontrolmode::CBR_HQ:
+		case ratecontrolmode::CBR_LD_HQ:
+			have_bitrate = true;
+			av_opt_set_int(context->priv_data, "cbr", 1, 0);
+			break;
+		case ratecontrolmode::VBR:
+		case ratecontrolmode::VBR_HQ:
+			have_bitrate_max = true;
+			have_bitrate     = true;
+			have_quality     = true;
+			have_qp_init     = true;
+			break;
+		}
+
+		PLOG_INFO("[%s]   Buffer Size: %" PRId64, codec->name, cfg_rc_bufsize);
+		if (have_bitrate)
+			PLOG_INFO("[%s]   Bitrate Target: %" PRId64, codec->name, cfg_rc_bitrate);
+		if (have_bitrate_max)
+			PLOG_INFO("[%s]   Bitrate Maximum: %" PRId64, codec->name, cfg_rc_max_bitrate);
+		if (have_quality && cfg_rc_quality) {
+			PLOG_INFO("[%s]   Quality Limits:", codec->name);
+			PLOG_INFO("[%s]     Minimum: %" PRId64, codec->name, cfg_rc_quality_min);
+			PLOG_INFO("[%s]     Maximum: %" PRId64, codec->name, cfg_rc_quality_max);
+			PLOG_INFO("[%s]     Target: %f", codec->name, cfg_rc_quality_tgt);
+		}
+		if (have_qp)
+			PLOG_INFO("[%s]   QP Values: %" PRId64 "/%" PRId64 "/%" PRId64, codec->name, cfg_rc_qp_i,
+			          cfg_rc_qp_p, cfg_rc_qp_b);
+		if (have_qp_init)
+			PLOG_INFO("[%s]   Initial QP Values: %" PRId64 "/%" PRId64 "/%" PRId64, codec->name,
+			          cfg_rc_qp_i_init, cfg_rc_qp_p_init, cfg_rc_qp_b_init);
+	}
+
+	bool    cfg_aq_spatial  = obs_data_get_bool(settings, ST_AQ_SPATIAL);
+	int64_t cfg_aq_strength = obs_data_get_int(settings, ST_AQ_STRENGTH);
+	bool    cfg_aq_temporal = obs_data_get_bool(settings, ST_AQ_TEMPORAL);
+	if (cfg_aq_spatial)
+		PLOG_INFO("[%s]   Spatial AQ Enabled: Strength %" PRId64, codec->name, cfg_aq_strength);
+	if (cfg_aq_temporal)
+		PLOG_INFO("[%s]   Temporal AQ Enabled", codec->name);
+
+	int64_t    cfg_bf          = obs_data_get_int(settings, ST_OTHER_BFRAMES);
+	b_ref_mode cfg_bf_mode     = static_cast<b_ref_mode>(obs_data_get_int(settings, ST_OTHER_BFRAME_REFERENCEMODE));
+	bool       cfg_zerolatency = obs_data_get_bool(settings, ST_OTHER_ZEROLATENCY);
+	bool       cfg_weightp     = obs_data_get_bool(settings, ST_OTHER_WEIGHTED_PREDICTION);
+	bool       cfg_nonrefp     = obs_data_get_bool(settings, ST_OTHER_NONREFERENCE_PFRAMES);
+
+	PLOG_INFO("[%s]   B-Frames: %" PRId64, codec->name, cfg_bf);
+	auto found3 = b_ref_mode_to_opt.find(cfg_bf_mode);
+	if (found3 != b_ref_mode_to_opt.end())
+		PLOG_INFO("[%s]     Reference Mode: %s", codec->name, found3->second.c_str());
+	if (cfg_zerolatency)
+		PLOG_INFO("[%s]   Zero Latency Enabled", codec->name);
+	if (cfg_weightp)
+		PLOG_INFO("[%s]   Weighted Prediction Enabled", codec->name);
+	if (cfg_nonrefp)
+		PLOG_INFO("[%s]   Non-Ref P-Frames Enabled", codec->name);
+}

source/ui/nvenc_shared.hpp

@@ -84,5 +84,7 @@ namespace obsffmpeg {
 		void get_runtime_properties(obs_properties_t* props, const AVCodec* codec, AVCodecContext* context);
 
 		void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
+
+		void log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 	} // namespace nvenc
 } // namespace obsffmpeg

source/ui/prores_aw_handler.cpp

@@ -104,3 +104,11 @@ void obsffmpeg::ui::prores_aw_handler::update(obs_data_t* settings, const AVCode
 {
 	context->profile = static_cast<int>(obs_data_get_int(settings, P_PRORES_PROFILE));
 }
+
+void obsffmpeg::ui::prores_aw_handler::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
+{
+	for (auto ptr = codec->profiles; ptr->profile != FF_PROFILE_UNKNOWN; ptr++) {
+		if (ptr->profile == static_cast<int>(obs_data_get_int(settings, P_PRORES_PROFILE)))
+			PLOG_INFO("[%s]   Profile: %s", codec->name, ptr->name);
+	}
+}

source/ui/prores_aw_handler.hpp

@@ -45,6 +45,9 @@ namespace obsffmpeg {
 
 			virtual void update(obs_data_t* settings, const AVCodec* codec,
 			                    AVCodecContext* context) override;
+
+			virtual void log_options(obs_data_t* settings, const AVCodec* codec,
+			                         AVCodecContext* context) override;
 		};
 	} // namespace ui
 } // namespace obsffmpeg