need help with lua script (dynamic hdr-peak-percentile)

[geextahslex]

Hi, I would like to set dynamic hdr-peak-percentile values that are dependent on the average image brightness. So for example a dark cave scene would be hdr-peak-percentile=99.8 to make it a bit brighter and a bright daylight scene would be hdr-peak-percentile=100
So if average image brightness is below 50% = hdr-peak-percentile=99.8
and if above 50% = hdr-peak-percentile=100

Would something like this be possible?

Thanks for any help :)

[kasper93]

it should already be possible with a conditional profile

[geextahslex]

okay, how to setup a image brightness condition?

[kasper93]

something like. See https://mpv.io/manual/master/#command-interface-video-params for available values, I don't want what you want to achieve.

[peak-percentile]
profile-cond=get("video-params/max-fall") > 400
profile-restore=copy
hdr-peak-percentile=50

[geextahslex]

Okay but this profile only applies/checks once at the beginning, it's not dynamic in the sense of checking every second/frame

[geextahslex]

I think the input should be video-params/avg-pq-y instead of video-params/max-fall

[geextahslex]

I tried a lua script like this but it doesn't update hdr-peak-percentile on the fly

local function check_avg-pq-y(name, value)
    if value == nil then
        return
    end

    if value < 100 then
        mp.set_property("hdr-peak-percentile", "99.8")
    elseif value < 500 then
        mp.set_property("hdr-peak-percentile", "99.9")
    else
        mp.set_property("hdr-peak-percentile", "100")
    end
end

mp.observe_property("video-params/avg-pq-y", "native", check_max_fall)

[hooke007]

What's the check_max_fall function? You didn't define it at all...

[geextahslex]

I have no idea, I don't know how to build lua scripts, this is just what chatgpt came up with

[hooke007]

local function check(name, value)
    if value == nil then
        return
    end

    if value >= 0.7 and value < 1 then
        mp.set_property("hdr-peak-percentile", "99.8")
    elseif value >= 0.3 and value < 0.7 then
        mp.set_property("hdr-peak-percentile", "99.9")
    else
        mp.set_property("hdr-peak-percentile", "100")
    end
end

mp.observe_property("video-out-params/avg-pq-y", "native", check)

[geextahslex]

Wow thats amazing, thank you!!
I had to change the values. I didn't know which pq-y values are actually read so I made this check and adjusted the values to around 0.2
0.2 equals 20% to that Avg PQ value that is in braces (so the 2nd value, not the cd/m²)

local function check(name, value)
    if value == nil then
        return
    end

    -- Print the current avg-pq-y value
    mp.msg.info("Current avg-pq-y value: " .. tostring(value))

    if value < 0.2 then
        mp.set_property("hdr-peak-percentile", "99.8")
        mp.msg.info("avg-pq-y < 1, setting hdr-peak-percentile to 99.8")
    elseif value < 0.25 then
        mp.set_property("hdr-peak-percentile", "99.9")
        mp.msg.info("avg-pq-y < 2, setting hdr-peak-percentile to 99.9")
    else
        mp.set_property("hdr-peak-percentile", "100")
        mp.msg.info("avg-pq-y >= 2, setting hdr-peak-percentile to 100")
    end
end

mp.observe_property("video-out-params/avg-pq-y", "native", check)

[geextahslex]

Okay this is the end result

local target_contrast = 0
local current_contrast = 0
local easing_speed = 5.0
local last_update_time = mp.get_time()

local last_value = nil
local last_decision = -9 -- start assuming -9
local value_history = {}
local history_max_size = 30 -- about 0.6 seconds if you update 50x per sec

local base_deadzone = 0.05 -- minimum deadzone width
local max_deadzone = 0.05 -- maximum deadzone width when very noisy

local function ease(current, target, delta_time, speed)
    local difference = target - current
    return current + difference * math.min(speed * delta_time, 1)
end

local function calculate_deadzone()
    if #value_history < 2 then
        return base_deadzone
    end

    local sum_diff = 0
    for i = 2, #value_history do
        sum_diff = sum_diff + math.abs(value_history[i] - value_history[i-1])
    end

    local avg_diff = sum_diff / (#value_history - 1)

    -- map avg_diff to deadzone size
    local deadzone = math.min(base_deadzone + avg_diff * 5, max_deadzone)

    return deadzone
end

local function check(name, value)
    if value == nil then
        return
    end

    mp.msg.info("Current avg-pq-y value: " .. tostring(value))
	mp.msg.info("Current contrast value: " .. string.format("%.2f", current_contrast))

    table.insert(value_history, value)
    if #value_history > history_max_size then
        table.remove(value_history, 1)
    end

    local deadzone = calculate_deadzone()

    if last_value == nil then
        last_value = value
    end

    if value < 0.2 then
        target_contrast = 0
        last_decision = 0
    elseif value < (0.24 - deadzone) then
        target_contrast = -5
        last_decision = -5
    elseif value > (0.24 + deadzone) then
        target_contrast = -9
        last_decision = -9
    else
        -- within adaptive deadzone, stick to last decision
        target_contrast = last_decision
    end

    last_value = value
end

local function update_contrast()
    local now = mp.get_time()
    local delta_time = now - last_update_time
    last_update_time = now
    local new_contrast = ease(current_contrast, target_contrast, delta_time, easing_speed)
    if math.abs(new_contrast - current_contrast) > 0.01 then
        current_contrast = new_contrast
        mp.set_property("contrast", string.format("%.2f", current_contrast))
    end
end

mp.observe_property("video-out-params/avg-pq-y", "native", check)
mp.add_periodic_timer(0.02, update_contrast)