Function RunCpuCompositeBenchmark

examples/VulkanBenchmark.cpp:780–833

}

static TimingStats RunCpuCompositeBenchmark(const BenchmarkOptions& options, const QImage& overlay_image,
											 DecodeKind decode_kind, bool& used_hw_decode) {
	TimingStats stats;
	const auto total_start = Clock::now();
	GenericDecodeReader decoder(options, decode_kind);
	decoder.Open();
	used_hw_decode = false;

	RgbaFrameConverter converter;
	RenderLayout layout;
	QImage prepared_overlay;
	bool overlay_ready = false;
	for (int frame_index = 0; frame_index < options.max_frames; ++frame_index) {
		ScopedFrame input_frame;
		double decode_ms = 0.0;
		if (!decoder.NextFrame(input_frame, decode_ms))
			break;
		stats.decode_ms += decode_ms;
		used_hw_decode = used_hw_decode || decoder.UsingHwDecode();

		const auto composite_start = Clock::now();
		ScopedFrame rgba_frame = converter.Convert(input_frame.get());
		QImage source_image = QImageFromRgbaFrame(rgba_frame.get());
		if (!overlay_ready) {
			layout = ComputeRenderLayout(options, source_image.width(), source_image.height());
			prepared_overlay = PrepareOverlayImage(options, layout, overlay_image);
			overlay_ready = true;
		}
		QImage output(layout.output_width, layout.output_height, QImage::Format_RGBA8888_Premultiplied);
		output.fill(QColor("#101418"));

		QPainter painter(&output);
		painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
		painter.setRenderHint(QPainter::Antialiasing, true);
		painter.drawImage(output.rect(), source_image);
		painter.setOpacity(1.0);
		painter.drawImage(layout.overlay_x, layout.overlay_y, prepared_overlay);
		painter.end();
		const std::string row_name =
			decode_kind == DecodeKind::Cuda ? "CUDA->CPU" :
			decode_kind == DecodeKind::Vaapi ? "VAAPI->CPU" :
			decode_kind == DecodeKind::Vulkan ? "Vulkan->CPU" :
			"CPU->CPU";
		SaveDumpImage(options, row_name, frame_index + 1, output);
		const auto composite_end = Clock::now();

		stats.composite_ms += std::chrono::duration<double, std::milli>(composite_end - composite_start).count();
		stats.frames++;
	}

	decoder.Close();
	stats.total_ms = std::chrono::duration<double, std::milli>(Clock::now() - total_start).count();
	return stats;
}

static ScopedFrame ConvertQImageToAvFrame(const QImage& image) {
	QImage rgba = image.convertToFormat(QImage::Format_RGBA8888);