Function RunCpuBenchmark

examples/VulkanBenchmark.cpp:373–423

}

static TimingStats RunCpuBenchmark(const BenchmarkOptions& options, const QImage& overlay_image) {
	TimingStats stats;
	const auto total_start = Clock::now();

	FFmpegReader reader(options.video_path);
	reader.Open();

	const int64_t frame_limit = std::min<int64_t>(options.max_frames, reader.info.video_length);
	if (frame_limit <= 0) {
		reader.Close();
		return stats;
	}

	RenderLayout layout;
	QImage prepared_overlay;
	bool overlay_ready = false;
	for (int64_t frame_number = 1; frame_number <= frame_limit; ++frame_number) {
		const auto decode_start = Clock::now();
		std::shared_ptr<Frame> source_frame = reader.GetFrame(frame_number);
		const auto decode_end = Clock::now();
		stats.decode_ms += std::chrono::duration<double, std::milli>(decode_end - decode_start).count();

		const auto composite_start = Clock::now();
		const std::shared_ptr<QImage> source_image = source_frame->GetImage();
		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();
		SaveDumpImage(options, "CPU->CPU", static_cast<int>(frame_number), output);

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

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

static TimingStats RunCpuCompositeBenchmark(const BenchmarkOptions& options, const QImage& overlay_image,
											 DecodeKind decode_kind, bool& used_hw_decode);