Function get_encoder_settings

server/encoder/encoder_settings.cpp:274–387

}

std::array<encoder_settings, 3> get_encoder_settings(wivrn::vk_bundle & bundle, wivrn_session & session)
{
	configuration config;

	std::array<wivrn::encoder_settings, 3> res;
	const auto & info = session.get_info();
	const auto settings = *session.get_settings();

	prober prober{bundle, info};

	for (auto [src, dst]: std::ranges::zip_view(config.encoders, res))
	{
		dst.fps = session.default_fps();
		dst.options = src.options;
		dst.device = src.device;

		std::tie(dst.encoder_name, dst.codec) = prober.select_encoder(src);
	}

	auto width = align(info.stream_eye_width, 64);
	auto height = align(info.stream_eye_height, 64);
	// Ensure we don't try to encode too large images (only for left/right, ignore alpha)
	for (size_t i = 0; i < 2; ++i)
		check_video_size(res[i].encoder_name, res[i].codec, width, height);

	for (auto [i, dst]: std::ranges::enumerate_view(res))
	{
		dst.width = width;
		dst.height = height;
		if (i == 2) // alpha channel
			dst.height /= 2;
	}

	auto bit_depth = config.bit_depth ? config.bit_depth : info.bit_depth;

	if (bit_depth and bit_depth != 8 and bit_depth != 10)
		throw std::runtime_error("invalid bit-depth setting. supported values: 8, 10");

	if (std::ranges::contains(res, video_codec::h264, &encoder_settings::codec) or
	    std::ranges::contains(res, video_codec::raw, &encoder_settings::codec))
		bit_depth = 8;
	else if (not bit_depth)
		bit_depth = 10;

	auto check_format = [&](vk::Format format) {
		try
		{
			auto props = bundle.physical_device.getImageFormatProperties(
			        format,
			        vk::ImageType::e2D,
			        vk::ImageTiling::eOptimal,
			        vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc);
			return props.maxArrayLayers >= 3 and
			       props.maxExtent.depth >= 1 and
			       props.maxExtent.width >= width and
			       props.maxExtent.height >= height;
		}
		catch (vk::FormatNotSupportedError &)