mpv: Autocrop Script V2

require "mp.msg"
require "mp.options"
-- version 2.1


require "mp.msg"
require "mp.options"
-- version 2.1

local options = {
    -- behavior
    enable = true,
    stop_crop_afterstart = 0,      -- set to non zero value to disable cropping after X seconds
    force_stop_afterstart = 10,    -- value after which time crop is stopped if movie is in the force_movies list below
    new_known_ratio_timer = 0.5,   -- seconds after a ratio is considered stable
    fast_known_ratio_timer = 0.1,  -- seconds after a ratio is considered stable if it is already known and difference is small
    stable_known_ratio_timer = 10, -- seconds after a ratio is considered super stable and uses fast_known_ratio_timer
    allowed_ratios = "2.76 2.7 2.55 2.33 2.2 2 1.9 1.85 16/9 1.6 4/3 1.34",  -- list separated by space (ratios above 2.33 and below 2.5 are always allowed)
    ratios_extra_px = 4,           -- pixel margin added to check above ratios
    cropdetect_lim_c_full = 6,     -- maximum black level for full range content (0-255)
    cropdetect_lim_c_limited = 17, -- maximum black level for limited range content (16-235)
    zoom_min_ratio = 2.1,          -- min ratio that needs to be active to zoom to screen_ratio after crop (set > screen_ratio to disable), ratios > screen_ratio will have black bars
    screen_ratio = 2.4,            -- your screen ratio (required for zooming)
    stretch = 0.95,                -- minor stretch for all aspect ratios below 2.3
    stretch16_9 = 0.90,            -- 16/9 and 1.85:1 stretching factor
    postition_mode = 0,            -- video position for all content that is cropped and still has black bars on top and bottom 0 = center, 1 = bottom, 2 = top (relevant only if zoom_after_crop is false)
    print_mode = false,            -- shows new mode in UI when pressing "C"
    use_zoom = true,               -- use zoom instead of crop filter in fullscreen, the zoom method
}

-- movies to force stop_crop_afterstart (only relevant if stop_crop_afterstart = 0)
local force_movies = {
    "VideoFile.mkv",
}


read_options(options)

-- forward declaration
local cleanup, on_toggle


-- variables
local new_known_ratio_timer =    options.new_known_ratio_timer    * 1000
local fast_known_ratio_timer =   options.fast_known_ratio_timer   * 1000
local stable_known_ratio_timer = options.stable_known_ratio_timer * 1000
local unstable_timer = 0
local ratio_stable_timer, time_pos_prev, optioncode, cropdetect_limit = 0, 0, 0, 0
local zoom16by9, in_progress, use_zoom =  false, false, false
local collected, source, prev, active, known_long_stable, known_short_stable, zoomed = {}, {}, {}, {}, {}, {}, {}



local function has_value(tab, val, margin)
    for index, value in ipairs(tab) do
        if math.abs(value - val) <= margin then return true end
    end
    return false
end


local function has_value_pair(tab, val, margin)
    for index, value in ipairs(tab) do
        if math.abs(value.h - val.h) <= margin and math.abs(value.w - val.w) <= margin then return true end
    end
    return false
end


local function print_table_pair(tab)
     local t = ""
     local count = 0
    for index, value in ipairs(tab) do
       if count == 0 then t = string.format("%1.2f (%sx%s)",  value.w/value.h, value.w, value.h) end
         if count >= 1 then t = string.format(" %s, %1.2f (%sx%s)", t, value.w/value.h, value.w, value.h) end
         count = count + 1 
    end
    return t
end


function tablelength(tab)
  local count = 0
  for _ in pairs(tab) do count = count + 1 end
  return count
end


local function is_valid_ratio(data, softmode, extrap)
    local r = data.w / data.h
    local h_r = 0
        
    --ignore clear incorrect data        
    if data == nil or (data.w ~= source.w and r > 4.1/3) or data.h < math.floor(source.w / 2.8) then 
        return false
    end
    
    -- ratios bigger than 2.4 are super rare and only allowed if no other ratio was stable so far
    if r > 2.41 and tablelength(known_long_stable) > 0 then
        return false
    end
    
    if r > 2.33 and r < 2.5 then 
        h_r = math.floor(data.w / 2.33)
        local known = false
        for index, value in ipairs(known_long_stable) do
            if value.h <= h_r then
                known = true                
                if math.abs(value.h - data.h) <= extrap then return true end                
            end
        end        
        for index, value in ipairs(known_short_stable) do
            if value.h <= h_r then
                known = true    
                if math.abs(value.h - data.h) <= extrap then return true end                
            end
        end
        if known == false or softmode then return true end
    end
    
    for ratio in string.gmatch(options.allowed_ratios, "%S+%s?") do
        for a, b in string.gmatch(ratio, "(%d+)/(%d+)") do ratio = a / b end
        --calculate height in pixels from allowed ratios
        h_r = math.floor(data.w / ratio)        
        if math.abs(data.h - h_r) <= extrap then return true end
    end
    
    return false
end


local function resetZoomStatus()
    zoomed = {}
end


-- only relevant for 1.9:1 and higher
local function isZoomed()
    for index, value in ipairs(zoomed) do
        if value >= 1.9 then return true end
    end
    return false
end


local function is_filter_present(label)
    local filters = mp.get_property_native("vf")
    for _, filter in pairs(filters) do if filter["label"] == label then return true end end
    return false
end


local function remove_filter(label)
    if is_filter_present(label) then 
        mp.command(string.format("no-osd vf remove @%s", label)) 
    end
end


local function insert_cropdetect_filter()
    local function command()
        return mp.command(string.format("no-osd vf pre @mycrop-cropdetect:lavfi-cropdetect=limit=%d/255:round=2:reset=1:skip=0", cropdetect_limit))
    end
    if not command() then
        if not command() then return end
    end
end


local function zoom_check(base, name, ratio, rmin, rmax, ymove, scalex, scaley )
    local add = false
    if rmin == 0 then
        add = isZoomed()
    else
        if has_value(zoomed,name,0) then add = false else add = true end
    end
    if ratio >= rmin and ratio < rmax and (add or active.h == 0) then 
        resetZoomStatus()
        table.insert(zoomed, name)        
        mp.command(string.format("no-osd set video-scale-x %s", scalex * base ))
        mp.command(string.format("no-osd set video-scale-y %s", scaley * base ))    
        mp.command(string.format("no-osd set video-align-y %s", ymove  ))
        if ratio < options.screen_ratio then
            return 'with pos zoom'
        end
        if ratio > options.screen_ratio then
            return 'with neg zoom'
        end
        return 'no zoom needed'        
    end    
    return ''
end



local function resetZoom() 
    mp.command(string.format("%s set video-scale-x 1",  "no-osd" ))
    mp.command(string.format("%s set video-scale-y 1",  "no-osd" ))        
    mp.command(string.format("%s set video-align-y 0",  "no-osd" ))
end


local function process_metadata()
    in_progress = true 
    
    local mode = ""
    local t = mp.get_property_number("time-pos")
    if t == nil then return false end    
    local elapsed_time = (t - time_pos_prev) * 1000
    time_pos_prev = t
    
    if math.abs(collected.w - source.w) <= options.ratios_extra_px then -- assume source if difference is small
        collected.w = source.w 
    end
    if math.abs(collected.h - source.h) <= options.ratios_extra_px then -- assume source if difference is small
        collected.h = source.h
    end
    if math.abs(collected.h - prev.h) <= options.ratios_extra_px then -- assume previous value if difference is small and unstable
        collected.h = prev.h
    end
    if math.abs(collected.w - prev.w) <= options.ratios_extra_px then -- assume previous value if difference is small and unstable
        collected.w = prev.w
    end
    
    local out = "yes"
    --return if ratio is never valid
    if not is_valid_ratio(collected, true, options.ratios_extra_px) then    
        out = "no"
        ratio_stable_timer = 0
    end
            
    unstable_timer = unstable_timer + 1
    
    local ratio = collected.w / collected.h            
    if (math.abs(collected.h - prev.h) > 6 or math.abs(collected.w - prev.w) > options.ratios_extra_px) and unstable_timer < 10 then        
        ratio_stable_timer = 0
        fast_known_ratio_timer = 0 -- if there is a big change we take the ratio if we already know it
        mode = " fast"    
    else
        mode = " slow"
        ratio_stable_timer = math.floor(ratio_stable_timer + elapsed_time)
        fast_known_ratio_timer =  options.fast_known_ratio_timer * 1000 * unstable_timer
    end    
    
    t = tablelength(known_long_stable)
    if t <= 1 and ratio > 1.7 then --source ratio and first ratio detected are fast, others a bit slower
        stable_timer = stable_known_ratio_timer
        if mp.get_property_number("time-pos") < 10 and active.h == 0 then
            new_timer = 100 --ms
            mode = " start"
        else
            new_timer = new_known_ratio_timer 
        end
    else 
        stable_timer = stable_known_ratio_timer * 2
        new_timer = new_known_ratio_timer * 2
    end    
    
    --print(string.format("%s %s %5.2f %5.2f %5.2f %s %s",collected.h, collected.w, ratio_stable_timer/1000, fast_known_ratio_timer/1000, new_timer/1000, out, unstable_timer))
    
    prev.h = collected.h    
    prev.w = collected.w
    if out == "no" then return false end    
    
    --return if ratio is invalid and not in table
    if not is_valid_ratio(collected, false, options.ratios_extra_px) then return false end    
                    
    --long stable ratios
    if ratio_stable_timer >= stable_timer then
        if not has_value_pair(known_long_stable, collected, 6) then
            table.insert(known_long_stable, collected)
            print(string.format("inserted long stable [%s]", print_table_pair(known_long_stable)))            
        end
    end
    
    if ratio_stable_timer >= 1000 then
        unstable_timer = 0
    end    
    
    --return if ratio is not stable yet
    if not has_value_pair(known_long_stable, collected, options.ratios_extra_px) then
        mode = mode .. " new"
        if ratio_stable_timer < new_timer then return false end                
    else        
        mode = mode .. " known"
        if ratio_stable_timer < fast_known_ratio_timer then return false    end        
    end
    

    --return if its already cropped with margin and below 6 pixels difference
    if math.abs(active.h - collected.h) <= 6 and math.abs(active.w - collected.w) == 0 then return false end
    

    local base = 1
    local isf = mp.get_property_bool("fullscreen")
    --if we are here its valid and we crop and stuff                            
    if use_zoom and isf then
        base = source.h/collected.h
    else
        mp.command(string.format("no-osd vf append @mycrop-crop:lavfi-crop=%s", collected.whxy))    
    end    
    
    mp.commandv('script-message', 'infocrop', string.format("%.2f",ratio))         
    
    if not has_value_pair(known_short_stable, collected, 0) then
        table.insert(known_short_stable, collected)
    end
        
    local z = ''
    local rate = 1
    if (ratio >= options.zoom_min_ratio or zoom16by9) then        
        if (ratio < options.screen_ratio) then    
             rate = options.screen_ratio/ratio
        else
             rate = ratio/options.screen_ratio
        end
        z = z .. zoom_check(base, 1.9 , ratio, 1.89, 1.91, 0.51 , rate, rate * options.stretch )
        z = z .. zoom_check(base, 2.0 , ratio, 1.99, 2.01, 0.505, rate, rate * options.stretch )
        z = z .. zoom_check(base, 2.2 , ratio, 2.19, 2.21, 0    , rate, rate * (1-((1-options.stretch)/2)))
        z = z .. zoom_check(base, 2.3 , ratio, 2.29, 2.5 , 0    , rate, rate )            
        if zoom16by9 then    
            z = z .. zoom_check(base, 1.77 , ratio, 1.760, 1.783, 0.51 , rate, rate * options.stretch16_9 )
            z = z .. zoom_check(base, 1.85 , ratio, 1.845, 1.859, 0.51 , rate, rate * options.stretch16_9 )
            z = z .. zoom_check(base, 1.33 , ratio, 0    , 1.760, 0    , 1, 1 ) -- no zoom below 16:9
        else                            
            z = z .. zoom_check(base, 1.33 , ratio, 0    , 1.890, 0    , 1, 1 ) -- no zoom below 16:9                                                
        end
    else
        z = z .. zoom_check(base, 1.33 , ratio, 0    , 3 , 0    , 1, 1 ) -- no zoom below 16:9            
    end    
    
    active.h = collected.h
    active.w = collected.w
    print(string.format("cropping%s %1.2f (%sx%s) %s", mode, ratio, collected.w,collected.h, z ))    
end




local function collect_metadata(_, table_)
    -- check the new metadata for availability and change
    if table_ and table_["lavfi.cropdetect.w"] and table_["lavfi.cropdetect.h"] then
        collected = {
            w = tonumber(table_["lavfi.cropdetect.w"]),
            h = tonumber(table_["lavfi.cropdetect.h"]),
            x = tonumber(table_["lavfi.cropdetect.x"]),
            y = tonumber(table_["lavfi.cropdetect.y"])
        }
        collected.whxy = string.format("w=%s:h=%s:x=%s:y=%s", collected.w, collected.h, collected.x, collected.y)    
        if in_progress == false then
            process_metadata()
            in_progress = false
        end
    end
end

local function collect_data()
    -- check the new metadata for availability and change
    local table_ = mp.get_property_native("vf-metadata/mycrop-cropdetect")
    if table_ and table_["lavfi.cropdetect.w"] and table_["lavfi.cropdetect.h"] then
        collected = {
            w = tonumber(table_["lavfi.cropdetect.w"]),
            h = tonumber(table_["lavfi.cropdetect.h"]),
            x = tonumber(table_["lavfi.cropdetect.x"]),
            y = tonumber(table_["lavfi.cropdetect.y"])
        }
        collected.whxy = string.format("w=%s:h=%s:x=%s:y=%s", collected.w, collected.h, collected.x, collected.y)    
        if in_progress == false then
            process_metadata()
            in_progress = false
        end
    end
end

local function periodic_check()
    --collect_data()
    if in_progress == false and collected.whxy ~= nil and mp.get_property_bool("pause") == false then
        process_metadata()
        in_progress = false
    end
end


local function observe_main_events(observe)
    if observe then
        mp.observe_property("vf-metadata/mycrop-cropdetect", "native", collect_metadata)
        insert_cropdetect_filter()
    else
        mp.unobserve_property(collect_metadata)
        remove_filter("mycrop-cropdetect")        
    end
end


local function stop_check()
    observe_main_events(false)
    collected = {}
    time_pos_prev = mp.get_property_number("time-pos")
    resetZoomStatus()
end


local function start_check()
    observe_main_events(true)
end


local function seek_event(event, id, error)
    ratio_stable_timer = 0
    time_pos_prev = mp.get_property_number("time-pos")
end


local function pause(_, bool)
    time_pos_prev = mp.get_property_number("time-pos")
end


local function fullscreen(_, bool)    
    if use_zoom then
        resetZoomStatus()
        --resetZoom()
        remove_filter("mycrop-crop")    
        --time_pos_prev = mp.get_property_number("time-pos")
        --ratio_stable_timer = 0
        active.h = 0
        active.w = 0
    end
end


function on_toggle(auto)
    optioncode = optioncode + 1
    if optioncode == 6 then 
        optioncode = 0 
        stop_crop_afterstart = 0
    end
    
    if auto then    
        optioncode = 1
        stop_crop_afterstart = 0 -- set this because of manual enable
    else
        active.h, active.w = 0, 0
    end
        
    if optioncode == 0 then -- auto crop enabled 
        zoom16by9 = false
        start_check()
        if options.print_mode and auto == nil then mp.osd_message("mycrop: default mode",1) end
    end
    
    if optioncode == 1 or optioncode == -1 then -- disable dynamic cropping
        stop_check()
        if options.print_mode and auto == nil then mp.osd_message("mycrop: freeze",1) end
    end            
    
    if optioncode == 2 then -- auto crop enabled with 16/9 crop
        zoom16by9 = true
        start_check()
        if options.print_mode and auto == nil then mp.osd_message("mycrop: full zoom mode",1) end
    end
    
    if optioncode == 3 then -- disable dynamic cropping
        stop_check()
        if options.print_mode and auto == nil then mp.osd_message("mycrop: freeze",1) end
    end

    if optioncode == 4 then -- disable dynamic cropping and show original aspect ratio        
        remove_filter("mycrop-crop")            
        stop_check()
        resetZoom()
        mp.command(string.format("no-osd vf append @mycrop-crop:lavfi-crop=w=%s:h=%s:x=%s:y=%s", 3840, 1600, 0, 280))    
        if options.print_mode and auto == nil then mp.osd_message("mycrop: forced mode",1) end
    end    
    
    if optioncode == 5 then -- disable dynamic cropping and show original aspect ratio
        remove_filter("mycrop-crop")            
        stop_check()
        resetZoom()
        if options.print_mode and auto == nil then mp.osd_message("mycrop: raw mode",1) end
    end
    
    mp.commandv('script-message', 'modecrop', optioncode)         
end


function cleanup()
    print("Cleanup.")
    -- unregister events
    observe_main_events(false)
    mp.unregister_event(seek_event)
    mp.unobserve_property(pause)
    mp.unobserve_property(fullscreen)
    -- remove existing filters
    remove_filter("mycrop-crop")    
    remove_filter("mycrop-cropdetect")    
    
    collected, source, prev, active, known_long_stable, known_short_stable, zoomed = {}, {}, {}, {}, {}, {}, {}
    ratio_stable_timer, time_pos_prev, optioncode = 0, 0, 0
    zoom16by9, in_progress = false, false
end


local function resetmode()
    resetZoomStatus()
    resetZoom()
    remove_filter("mycrop-crop")    
    optioncode = -1
    stop_crop_afterstart = 0
    known_long_stable = {}
    known_short_stable = {}
    time_pos_prev = mp.get_property_number("time-pos")
    ratio_stable_timer = 0
    active.h = 0
    active.w = 0
    
    on_toggle(nil)
end


local function stopupdate()
    if stop_crop_afterstart ~= 0 and optioncode == 0 then
        on_toggle(true)        
    end
end


local function on_start()
    if not options.enable then    return end
    
    use_zoom = options.use_zoom

    optioncode = -1
    mp.commandv('script-message', 'modecrop', optioncode) 
    stop_crop_afterstart = options.stop_crop_afterstart
    
    source.w = mp.get_property_number("width")
    source.h = mp.get_property_number("height")    
    prev.h  , prev.w   = 0, 0
    active.h, active.w = 0, 0
    mp.commandv('script-message', 'infocrop', string.format("%.2f",source.w/source.h))     
    time_pos_prev = mp.get_property_number("time-pos")
    
    -- register events    
    mp.register_event("seek", seek_event)
    mp.observe_property("pause", "bool", pause)
    mp.observe_property("fullscreen", "bool", fullscreen)
    
    mp.add_periodic_timer(0.25, function() periodic_check() end)
    
    --special movies
    for index, value in ipairs(force_movies) do 
        if string.lower(value) == string.lower(mp.get_property("filename")) then
            stop_crop_afterstart = options.force_stop_afterstart
            print("special movie, stopping crop after "..stop_crop_afterstart.." sec")
        end
    end
        
    if stop_crop_afterstart ~= 0 then
        counter = mp.add_timeout(stop_crop_afterstart,function () stopupdate() end)
    end    
    
    if options.postition_mode == 0 then
        mp.command(string.format("no-osd set video-align-y 0" ))
    end
    if options.postition_mode == 1 then
        mp.command(string.format("no-osd set video-align-y 1" ))
    end
    if options.postition_mode == 2 then
        mp.command(string.format("no-osd set video-align-y -1" ))
    end
    
    while mp.get_property("video-params/colorlevels") == nil do
        local time = mp.get_time()
        while time + 0.1 > mp.get_time() and mp.get_property_bool("eof-reached") == false do end
    end
    
    if mp.get_property("video-params/colorlevels") == "full" then
        cropdetect_limit = options.cropdetect_lim_c_full
    else
        cropdetect_limit = options.cropdetect_lim_c_limited
    end    
           
    on_toggle(false)
    
end


mp.add_key_binding("C", "toggle_crop", on_toggle)
mp.add_key_binding("X", "cropresetmode", resetmode)
mp.register_event("end-file", cleanup)
mp.register_event("file-loaded", on_start)