Velix-MPV-Core/video/harmony_hwdec.c

/*
 * This file is part of mpv.
 *
 * mpv is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 */

#include <pthread.h>
#include <stdio.h>
#include <string.h>

#include "video/harmony_hwdec.h"

static pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER;
static struct mpv_harmony_hwdec_stats stats = {
    .state = MP_HARMONY_HWDEC_DISABLED,
};

static void copy_text(char *dst, const char *src)
{
    snprintf(dst, MP_HARMONY_HWDEC_TEXT, "%s", src ? src : "");
}

MPV_EXPORT void mpv_harmony_hwdec_set_requested(int requested)
{
    pthread_mutex_lock(&stats_lock);
    stats.hwdec_requested = !!requested;
    stats.state = requested ? MP_HARMONY_HWDEC_REQUESTED : MP_HARMONY_HWDEC_DISABLED;
    if (!requested) {
        stats.hwdec_active = 0;
        stats.fallback_reason[0] = '\0';
        stats.decoder_name[0] = '\0';
    }
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_set_state(enum mp_harmony_hwdec_state state)
{
    pthread_mutex_lock(&stats_lock);
    stats.state = state;
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_set_active(const char *backend,
                                             const char *device_type)
{
    pthread_mutex_lock(&stats_lock);
    stats.hwdec_active = 1;
    stats.state = MP_HARMONY_HWDEC_ACTIVE;
    copy_text(stats.hwdec_backend, backend);
    copy_text(stats.hw_device_type, device_type);
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_set_decoder(const char *decoder_name)
{
    pthread_mutex_lock(&stats_lock);
    copy_text(stats.decoder_name, decoder_name);
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_set_capability(const char *summary)
{
    pthread_mutex_lock(&stats_lock);
    copy_text(stats.capability_summary, summary);
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_set_fallback(const char *reason)
{
    pthread_mutex_lock(&stats_lock);
    stats.hwdec_active = 0;
    stats.state = MP_HARMONY_HWDEC_FALLBACK;
    stats.hw_fallback_count++;
    copy_text(stats.fallback_reason, reason);
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_record_hardware_frame(void)
{
    pthread_mutex_lock(&stats_lock);
    stats.hardware_frame_count++;
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_record_software_frame(void)
{
    pthread_mutex_lock(&stats_lock);
    stats.software_frame_count++;
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_record_surface_present(void)
{
    pthread_mutex_lock(&stats_lock);
    stats.surface_present_count++;
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT void mpv_harmony_hwdec_record_gpu_interop_frame(void)
{
    pthread_mutex_lock(&stats_lock);
    stats.gpu_interop_frame_count++;
    stats.native_buffer_import_count++;
    pthread_mutex_unlock(&stats_lock);
}

MPV_EXPORT int mpv_harmony_hwdec_get_stats(struct mpv_harmony_hwdec_stats *out)
{
    if (!out)
        return 0;
    pthread_mutex_lock(&stats_lock);
    *out = stats;
    pthread_mutex_unlock(&stats_lock);
    return 1;
}