Ways to Measure FPS When Playing Video with FFmpeg and C++ in a Slint App

[metahead00]

Hi! I'm building a C++ app with a Slint UI that plays video using FFmpeg, and I'm trying to measure the actual FPS (frames per second) during playback.

Right now, I use a std::condition_variable to synchronize frame decoding and rendering, and I count how many frames are displayed each second to measure FPS.

It works, but I suspect that it might be affecting performance, since I get around 48–50 FPS on my PC, but only 8–9 FPS on my tablet. So I’m wondering:

Is there a better or more accurate way to measure FPS in this setup?

How do others typically measure FPS in a Slint app?

Any insight, suggestions, or best practices would be appreciated!

Thanks 🙏

Here is the C++ snippet in case:

while(running)
    std::mutex m;
    std::condition_variable cv;
    bool updated = false;

    if (packet->stream_index == video_stream_index) {
        avcodec_send_packet(codec_ctx, packet);
        if (avcodec_receive_frame(codec_ctx, frame) == 0) {
            sws_scale(sws_ctx, frame->data, frame->linesize, 0, codec_ctx->height,
                      rgba_frame->data, rgba_frame->linesize);

            slint::SharedPixelBuffer<slint::Rgba8Pixel> buffer(
                codec_ctx->width, codec_ctx->height,
                reinterpret_cast<const slint::Rgba8Pixel*>(rgba_buffer.data())
            );

            slint::Image image(buffer);
            slint::invoke_from_event_loop([ui, image, &updated, &cv] {
                ui->set_frame(image);
                updated = true;
                cv.notify_one();
            });

            std::unique_lock<std::mutex> lock(m);
            cv.wait(lock, [&] { return updated; });
        }
    }

    av_packet_unref(packet);
    frame_count++;

    auto now = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - last_time).count();

    // Calculation
    if (elapsed >= 1) {
        slint::invoke_from_event_loop([ui, frame_count] {
            ui->set_fps(frame_count);
        });
        average_fps = (average_fps*time + frame_count) / (time+1);
        time++;
        min_fps = std::min(min_fps, static_cast<double>(frame_count));
        // std::cout << "FPS: " << frame_count << "\n";
        frame_count = 0;
        last_time = now;
    }
}
av_frame_free(&rgba_frame);