path: root/mac/.config/mpv/scripts/mpv_crop_script.lua

--[[
    Copyright (C) 2017 AMM

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
]]
--
--[[
    mpv_crop_script.lua 0.5.0 - commit 472281e (branch master)
    Built on 2018-09-30 14:22:46
]]
--
--[[
  Assorted helper functions, from checking falsey values to path utils
  to escaping and wrapping strings.

  Does not depend on other libs.
]]
--

local assdraw = require("mp.assdraw")
local msg = require("mp.msg")
local utils = require("mp.utils")

-- Determine platform --
ON_WINDOWS = (package.config:sub(1, 1) ~= "/")

-- Some helper functions needed to parse the options --
function isempty(v)
	return (v == false) or (v == nil) or (v == "") or (v == 0) or (type(v) == "table" and next(v) == nil)
end

function divmod(a, b)
	return math.floor(a / b), a % b
end

-- Better modulo
function bmod(i, N)
	return (i % N + N) % N
end

-- Path utils
local path_utils = {
	abspath = true,
	split = true,
	dirname = true,
	basename = true,

	isabs = true,
	normcase = true,
	splitdrive = true,
	join = true,
	normpath = true,
	relpath = true,
}

-- Helpers
path_utils._split_parts = function(path, sep)
	local path_parts = {}
	for c in path:gmatch("[^" .. sep .. "]+") do
		table.insert(path_parts, c)
	end
	return path_parts
end

-- Common functions
path_utils.abspath = function(path)
	if not path_utils.isabs(path) then
		local cwd = os.getenv("PWD") or utils.getcwd()
		path = path_utils.join(cwd, path)
	end
	return path_utils.normpath(path)
end

path_utils.split = function(path)
	local drive, path = path_utils.splitdrive(path)
	-- Technically unix path could contain a \, but meh
	local first_index, last_index = path:find("^.*[/\\]")

	if last_index == nil then
		return drive .. "", path
	else
		local head = path:sub(0, last_index - 1)
		local tail = path:sub(last_index + 1)
		if head == "" then
			head = sep
		end
		return drive .. head, tail
	end
end

path_utils.dirname = function(path)
	local head, tail = path_utils.split(path)
	return head
end

path_utils.basename = function(path)
	local head, tail = path_utils.split(path)
	return tail
end

path_utils.expanduser = function(path)
	-- Expands the following from the start of the path:
	-- ~ to HOME
	-- ~~ to mpv config directory (first result of mp.find_config_file('.'))
	-- ~~desktop to Windows desktop, otherwise HOME
	-- ~~temp to Windows temp or /tmp/

	local first_index, last_index = path:find("^.-[/\\]")
	local head = path
	local tail = ""

	local sep = ""

	if last_index then
		head = path:sub(0, last_index - 1)
		tail = path:sub(last_index + 1)
		sep = path:sub(last_index, last_index)
	end

	if head == "~~desktop" then
		head = ON_WINDOWS and path_utils.join(os.getenv("USERPROFILE"), "Desktop") or os.getenv("HOME")
	elseif head == "~~temp" then
		head = ON_WINDOWS and os.getenv("TEMP") or (os.getenv("TMP") or "/tmp/")
	elseif head == "~~" then
		local mpv_config_dir = mp.find_config_file(".")
		if mpv_config_dir then
			head = path_utils.dirname(mpv_config_dir)
		else
			msg.warn("Could not find mpv config directory (using mp.find_config_file), using temp instead")
			head = ON_WINDOWS and os.getenv("TEMP") or (os.getenv("TMP") or "/tmp/")
		end
	elseif head == "~" then
		head = ON_WINDOWS and os.getenv("USERPROFILE") or os.getenv("HOME")
	end

	return path_utils.normpath(path_utils.join(head .. sep, tail))
end

if ON_WINDOWS then
	local sep = "\\"
	local altsep = "/"
	local curdir = "."
	local pardir = ".."
	local colon = ":"

	local either_sep = function(c)
		return c == sep or c == altsep
	end

	path_utils.isabs = function(path)
		local prefix, path = path_utils.splitdrive(path)
		return either_sep(path:sub(1, 1))
	end

	path_utils.normcase = function(path)
		return path:gsub(altsep, sep):lower()
	end

	path_utils.splitdrive = function(path)
		if #path >= 2 then
			local norm = path:gsub(altsep, sep)
			if (norm:sub(1, 2) == (sep .. sep)) and (norm:sub(3, 3) ~= sep) then
				-- UNC path
				local index = norm:find(sep, 3)
				if not index then
					return "", path
				end

				local index2 = norm:find(sep, index + 1)
				if index2 == index + 1 then
					return "", path
				elseif not index2 then
					index2 = path:len()
				end

				return path:sub(1, index2 - 1), path:sub(index2)
			elseif norm:sub(2, 2) == colon then
				return path:sub(1, 2), path:sub(3)
			end
		end
		return "", path
	end

	path_utils.join = function(path, ...)
		local paths = { ... }

		local result_drive, result_path = path_utils.splitdrive(path)

		function inner(p)
			local p_drive, p_path = path_utils.splitdrive(p)
			if either_sep(p_path:sub(1, 1)) then
				-- Path is absolute
				if p_drive ~= "" or result_drive == "" then
					result_drive = p_drive
				end
				result_path = p_path
				return
			elseif p_drive ~= "" and p_drive ~= result_drive then
				if p_drive:lower() ~= result_drive:lower() then
					-- Different paths, ignore first
					result_drive = p_drive
					result_path = p_path
					return
				end
			end

			if result_path ~= "" and not either_sep(result_path:sub(-1)) then
				result_path = result_path .. sep
			end
			result_path = result_path .. p_path
		end

		for i, p in ipairs(paths) do
			inner(p)
		end

		-- add separator between UNC and non-absolute path
		if
			result_path ~= ""
			and not either_sep(result_path:sub(1, 1))
			and result_drive ~= ""
			and result_drive:sub(-1) ~= colon
		then
			return result_drive .. sep .. result_path
		end
		return result_drive .. result_path
	end

	path_utils.normpath = function(path)
		if path:find("\\\\.\\", nil, true) == 1 or path:find("\\\\?\\", nil, true) == 1 then
			-- Device names and literal paths - return as-is
			return path
		end

		path = path:gsub(altsep, sep)
		local prefix, path = path_utils.splitdrive(path)

		if path:find(sep) == 1 then
			prefix = prefix .. sep
			path = path:gsub("^[\\]+", "")
		end

		local comps = path_utils._split_parts(path, sep)

		local i = 1
		while i <= #comps do
			if comps[i] == curdir then
				table.remove(comps, i)
			elseif comps[i] == pardir then
				if i > 1 and comps[i - 1] ~= pardir then
					table.remove(comps, i)
					table.remove(comps, i - 1)
					i = i - 1
				elseif i == 1 and prefix:match("\\$") then
					table.remove(comps, i)
				else
					i = i + 1
				end
			else
				i = i + 1
			end
		end

		if prefix == "" and #comps == 0 then
			comps[1] = curdir
		end

		return prefix .. table.concat(comps, sep)
	end

	path_utils.relpath = function(path, start)
		start = start or curdir

		local start_abs = path_utils.abspath(path_utils.normpath(start))
		local path_abs = path_utils.abspath(path_utils.normpath(path))

		local start_drive, start_rest = path_utils.splitdrive(start_abs)
		local path_drive, path_rest = path_utils.splitdrive(path_abs)

		if path_utils.normcase(start_drive) ~= path_utils.normcase(path_drive) then
			-- Different drives
			return nil
		end

		local start_list = path_utils._split_parts(start_rest, sep)
		local path_list = path_utils._split_parts(path_rest, sep)

		local i = 1
		for j = 1, math.min(#start_list, #path_list) do
			if path_utils.normcase(start_list[j]) ~= path_utils.normcase(path_list[j]) then
				break
			end
			i = j + 1
		end

		local rel_list = {}
		for j = 1, (#start_list - i + 1) do
			rel_list[j] = pardir
		end
		for j = i, #path_list do
			table.insert(rel_list, path_list[j])
		end

		if #rel_list == 0 then
			return curdir
		end

		return path_utils.join(unpack(rel_list))
	end
else
	-- LINUX
	local sep = "/"
	local curdir = "."
	local pardir = ".."

	path_utils.isabs = function(path)
		return path:sub(1, 1) == "/"
	end
	path_utils.normcase = function(path)
		return path
	end
	path_utils.splitdrive = function(path)
		return "", path
	end

	path_utils.join = function(path, ...)
		local paths = { ... }

		for i, p in ipairs(paths) do
			if p:sub(1, 1) == sep then
				path = p
			elseif path == "" or path:sub(-1) == sep then
				path = path .. p
			else
				path = path .. sep .. p
			end
		end

		return path
	end

	path_utils.normpath = function(path)
		if path == "" then
			return curdir
		end

		local initial_slashes = (path:sub(1, 1) == sep) and 1
		if initial_slashes and path:sub(2, 2) == sep and path:sub(3, 3) ~= sep then
			initial_slashes = 2
		end

		local comps = path_utils._split_parts(path, sep)
		local new_comps = {}

		for i, comp in ipairs(comps) do
			if comp == "" or comp == curdir then
			-- pass
			elseif
				comp ~= pardir
				or (not initial_slashes and #new_comps == 0)
				or (#new_comps > 0 and new_comps[#new_comps] == pardir)
			then
				table.insert(new_comps, comp)
			elseif #new_comps > 0 then
				table.remove(new_comps)
			end
		end

		comps = new_comps
		path = table.concat(comps, sep)
		if initial_slashes then
			path = sep:rep(initial_slashes) .. path
		end

		return (path ~= "") and path or curdir
	end

	path_utils.relpath = function(path, start)
		start = start or curdir

		local start_abs = path_utils.abspath(path_utils.normpath(start))
		local path_abs = path_utils.abspath(path_utils.normpath(path))

		local start_list = path_utils._split_parts(start_abs, sep)
		local path_list = path_utils._split_parts(path_abs, sep)

		local i = 1
		for j = 1, math.min(#start_list, #path_list) do
			if start_list[j] ~= path_list[j] then
				break
			end
			i = j + 1
		end

		local rel_list = {}
		for j = 1, (#start_list - i + 1) do
			rel_list[j] = pardir
		end
		for j = i, #path_list do
			table.insert(rel_list, path_list[j])
		end

		if #rel_list == 0 then
			return curdir
		end

		return path_utils.join(unpack(rel_list))
	end
end
-- Path utils end

-- Check if path is local (by looking if it's prefixed by a proto://)
local path_is_local = function(path)
	local proto = path:match("(..-)://")
	return proto == nil
end

function Set(source)
	local set = {}
	for _, l in ipairs(source) do
		set[l] = true
	end
	return set
end

---------------------------
-- More helper functions --
---------------------------

function busy_wait(seconds)
	local target = mp.get_time() + seconds
	local cycles = 0
	while target > mp.get_time() do
		cycles = cycles + 1
	end
	return cycles
end

-- Removes all keys from a table, without destroying the reference to it
function clear_table(target)
	for key, value in pairs(target) do
		target[key] = nil
	end
end
function shallow_copy(target)
	if type(target) == "table" then
		local copy = {}
		for k, v in pairs(target) do
			copy[k] = v
		end
		return copy
	else
		return target
	end
end

function deep_copy(target)
	local copy = {}
	for k, v in pairs(target) do
		if type(v) == "table" then
			copy[k] = deep_copy(v)
		else
			copy[k] = v
		end
	end
	return copy
end

-- Rounds to given decimals. eg. round_dec(3.145, 0) => 3
function round_dec(num, idp)
	local mult = 10 ^ (idp or 0)
	return math.floor(num * mult + 0.5) / mult
end

function file_exists(name)
	local f = io.open(name, "rb")
	if f ~= nil then
		local ok, err, code = f:read(1)
		io.close(f)
		return code == nil
	else
		return false
	end
end

function path_exists(name)
	local f = io.open(name, "rb")
	if f ~= nil then
		io.close(f)
		return true
	else
		return false
	end
end

function create_directories(path)
	local cmd
	if ON_WINDOWS then
		cmd = { args = { "cmd", "/c", "mkdir", path } }
	else
		cmd = { args = { "mkdir", "-p", path } }
	end
	utils.subprocess(cmd)
end

function move_file(source_path, target_path)
	local cmd
	if ON_WINDOWS then
		cmd = { cancellable = false, args = { "cmd", "/c", "move", "/Y", source_path, target_path } }
		utils.subprocess(cmd)
	else
		-- cmd = { cancellable=false, args = {'mv', source_path, target_path } }
		os.rename(source_path, target_path)
	end
end

function check_pid(pid)
	-- Checks if a PID exists and returns true if so
	local cmd, r
	if ON_WINDOWS then
		cmd = { cancellable = false, args = {
			"tasklist",
			"/FI",
			("PID eq %d"):format(pid),
		} }
		r = utils.subprocess(cmd)
		return r.stdout:sub(1, 1) == "\13"
	else
		cmd = { cancellable = false, args = {
			"sh",
			"-c",
			("kill -0 %d 2>/dev/null"):format(pid),
		} }
		r = utils.subprocess(cmd)
		return r.status == 0
	end
end

function kill_pid(pid)
	local cmd, r
	if ON_WINDOWS then
		cmd = { cancellable = false, args = { "taskkill", "/F", "/PID", tostring(pid) } }
	else
		cmd = { cancellable = false, args = { "kill", tostring(pid) } }
	end
	r = utils.subprocess(cmd)
	return r.status == 0, r
end

-- Find an executable in PATH or CWD with the given name
function find_executable(name)
	local delim = ON_WINDOWS and ";" or ":"

	local pwd = os.getenv("PWD") or utils.getcwd()
	local path = os.getenv("PATH")

	local env_path = pwd .. delim .. path -- Check CWD first

	local result, filename
	for path_dir in env_path:gmatch("[^" .. delim .. "]+") do
		filename = path_utils.join(path_dir, name)
		if file_exists(filename) then
			result = filename
			break
		end
	end

	return result
end

local ExecutableFinder = { path_cache = {} }
-- Searches for an executable and caches the result if any
function ExecutableFinder:get_executable_path(name, raw_name)
	name = ON_WINDOWS and not raw_name and (name .. ".exe") or name

	if self.path_cache[name] == nil then
		self.path_cache[name] = find_executable(name) or false
	end
	return self.path_cache[name]
end

-- Format seconds to HH.MM.SS.sss
function format_time(seconds, sep, decimals)
	decimals = decimals == nil and 3 or decimals
	sep = sep and sep or ":"
	local s = seconds
	local h, s = divmod(s, 60 * 60)
	local m, s = divmod(s, 60)

	local second_format = string.format("%%0%d.%df", 2 + (decimals > 0 and decimals + 1 or 0), decimals)

	return string.format("%02d" .. sep .. "%02d" .. sep .. second_format, h, m, s)
end

-- Format seconds to 1h 2m 3.4s
function format_time_hms(seconds, sep, decimals, force_full)
	decimals = decimals == nil and 1 or decimals
	sep = sep ~= nil and sep or " "

	local s = seconds
	local h, s = divmod(s, 60 * 60)
	local m, s = divmod(s, 60)

	if force_full or h > 0 then
		return string.format("%dh" .. sep .. "%dm" .. sep .. "%." .. tostring(decimals) .. "fs", h, m, s)
	elseif m > 0 then
		return string.format("%dm" .. sep .. "%." .. tostring(decimals) .. "fs", m, s)
	else
		return string.format("%." .. tostring(decimals) .. "fs", s)
	end
end

-- Writes text on OSD and console
function log_info(txt, timeout)
	timeout = timeout or 1.5
	msg.info(txt)
	mp.osd_message(txt, timeout)
end

-- Join table items, ala ({"a", "b", "c"}, "=", "-", ", ") => "=a-, =b-, =c-"
function join_table(source, before, after, sep)
	before = before or ""
	after = after or ""
	sep = sep or ", "
	local result = ""
	for i, v in pairs(source) do
		if not isempty(v) then
			local part = before .. v .. after
			if i == 1 then
				result = part
			else
				result = result .. sep .. part
			end
		end
	end
	return result
end

function wrap(s, char)
	char = char or "'"
	return char .. s .. char
end
-- Wraps given string into 'string' and escapes any 's in it
function escape_and_wrap(s, char, replacement)
	char = char or "'"
	replacement = replacement or "\\" .. char
	return wrap(string.gsub(s, char, replacement), char)
end
-- Escapes single quotes in a string and wraps the input in single quotes
function escape_single_bash(s)
	return escape_and_wrap(s, "'", "'\\''")
end

-- Returns (a .. b) if b is not empty or nil
function joined_or_nil(a, b)
	return not isempty(b) and (a .. b) or nil
end

-- Put items from one table into another
function extend_table(target, source)
	for i, v in pairs(source) do
		table.insert(target, v)
	end
end

-- Creates a handle and filename for a temporary random file (in current directory)
function create_temporary_file(base, mode, suffix)
	local handle, filename
	suffix = suffix or ""
	while true do
		filename = base .. tostring(math.random(1, 5000)) .. suffix
		handle = io.open(filename, "r")
		if not handle then
			handle = io.open(filename, mode)
			break
		end
		io.close(handle)
	end
	return handle, filename
end

function get_processor_count()
	local proc_count

	if ON_WINDOWS then
		proc_count = tonumber(os.getenv("NUMBER_OF_PROCESSORS"))
	else
		local cpuinfo_handle = io.open("/proc/cpuinfo")
		if cpuinfo_handle ~= nil then
			local cpuinfo_contents = cpuinfo_handle:read("*a")
			local _, replace_count = cpuinfo_contents:gsub("processor", "")
			proc_count = replace_count
		end
	end

	if proc_count and proc_count > 0 then
		return proc_count
	else
		return nil
	end
end

function substitute_values(string, values)
	local substitutor = function(match)
		if match == "%" then
			return "%"
		else
			-- nil is discarded by gsub
			return values[match]
		end
	end

	local substituted = string:gsub("%%(.)", substitutor)
	return substituted
end

-- ASS HELPERS --
function round_rect_top(ass, x0, y0, x1, y1, r)
	local c = 0.551915024494 * r -- circle approximation
	ass:move_to(x0 + r, y0)
	ass:line_to(x1 - r, y0) -- top line
	if r > 0 then
		ass:bezier_curve(x1 - r + c, y0, x1, y0 + r - c, x1, y0 + r) -- top right corner
	end
	ass:line_to(x1, y1) -- right line
	ass:line_to(x0, y1) -- bottom line
	ass:line_to(x0, y0 + r) -- left line
	if r > 0 then
		ass:bezier_curve(x0, y0 + r - c, x0 + r - c, y0, x0 + r, y0) -- top left corner
	end
end

function round_rect(ass, x0, y0, x1, y1, rtl, rtr, rbr, rbl)
	local c = 0.551915024494
	ass:move_to(x0 + rtl, y0)
	ass:line_to(x1 - rtr, y0) -- top line
	if rtr > 0 then
		ass:bezier_curve(x1 - rtr + rtr * c, y0, x1, y0 + rtr - rtr * c, x1, y0 + rtr) -- top right corner
	end
	ass:line_to(x1, y1 - rbr) -- right line
	if rbr > 0 then
		ass:bezier_curve(x1, y1 - rbr + rbr * c, x1 - rbr + rbr * c, y1, x1 - rbr, y1) -- bottom right corner
	end
	ass:line_to(x0 + rbl, y1) -- bottom line
	if rbl > 0 then
		ass:bezier_curve(x0 + rbl - rbl * c, y1, x0, y1 - rbl + rbl * c, x0, y1 - rbl) -- bottom left corner
	end
	ass:line_to(x0, y0 + rtl) -- left line
	if rtl > 0 then
		ass:bezier_curve(x0, y0 + rtl - rtl * c, x0 + rtl - rtl * c, y0, x0 + rtl, y0) -- top left corner
	end
end
--[[
  A slightly more advanced option parser for scripts.
  It supports documenting the options, and can export an example config.
  It also can rewrite the config file with overrides, preserving the
  original lines and appending changes to the end, along with profiles.

  Does not depend on other libs.
]]
--

local OptionParser = {}
OptionParser.__index = OptionParser

setmetatable(OptionParser, {
	__call = function(cls, ...)
		return cls.new(...)
	end,
})

function OptionParser.new(identifier)
	local self = setmetatable({}, OptionParser)

	self.identifier = identifier
	self.config_file = self:_get_config_file(identifier)

	self.OVERRIDE_START = "# Script-saved overrides below this line. Edits will be lost!"

	-- All the options contained, as a list
	self.options_list = {}
	-- All the options contained, as a table with keys. See add_option
	self.options = {}

	self.default_profile = { name = "default", values = {}, loaded = {}, config_lines = {} }
	self.profiles = {}

	self.active_profile = self.default_profile

	-- Recusing metatable magic to wrap self.values.key.sub_key into
	-- self.options["key.sub_key"].value, with support for assignments as well
	function get_value_or_mapper(key)
		local cur_option = self.options[key]

		if cur_option then
			-- Wrap tables
			if cur_option.type == "table" then
				return setmetatable({}, {
					__index = function(t, sub_key)
						return get_value_or_mapper(key .. "." .. sub_key)
					end,
					__newindex = function(t, sub_key, value)
						local sub_option = self.options[key .. "." .. sub_key]
						if sub_option and sub_option.type ~= "table" then
							self.active_profile.values[key .. "." .. sub_key] = value
						end
					end,
				})
			else
				return self.active_profile.values[key]
			end
		end
	end

	-- Same recusing metatable magic to get the .default
	function get_default_or_mapper(key)
		local cur_option = self.options[key]

		if cur_option then
			if cur_option.type == "table" then
				return setmetatable({}, {
					__index = function(t, sub_key)
						return get_default_or_mapper(key .. "." .. sub_key)
					end,
				})
			else
				return cur_option.default
				-- return self.active_profile.values[key]
			end
		end
	end

	-- Easy lookups for values and defaults
	self.values = setmetatable({}, {
		__index = function(t, key)
			return get_value_or_mapper(key)
		end,
		__newindex = function(t, key, value)
			local option = self.options[key]
			if option then
				-- option.value = value
				self.active_profile.values[key] = value
			end
		end,
	})

	self.defaults = setmetatable({}, {
		__index = function(t, key)
			return get_default_or_mapper(key)
		end,
	})

	-- Hacky way to run after the script is initialized and options (hopefully) added
	mp.add_timeout(0, function()
		-- Handle a '--script-opts identifier-example-config=example.conf' to save an example config to a file
		local example_dump_filename = mp.get_opt(self.identifier .. "-example-config")
		if example_dump_filename then
			self:save_example_options(example_dump_filename)
		end
		local explain_config = mp.get_opt(self.identifier .. "-explain-config")
		if explain_config then
			self:explain_options()
		end

		if (example_dump_filename or explain_config) and mp.get_property_native("options/idle") then
			msg.info("Exiting.")
			mp.commandv("quit")
		end
	end)

	return self
end

function OptionParser:activate_profile(profile_name)
	local chosen_profile = nil
	if profile_name then
		for i, profile in ipairs(self.profiles) do
			if profile.name == profile_name then
				chosen_profile = profile
				break
			end
		end
	else
		chosen_profile = self.default_profile
	end

	if chosen_profile then
		self.active_profile = chosen_profile
	end
end

function OptionParser:add_option(key, default, description, pad_before)
	if self.options[key] ~= nil then
		-- Already exists!
		return nil
	end

	local option_index = #self.options_list + 1
	local option_type = type(default)

	-- Check if option is an array
	if option_type == "table" then
		if default._array then
			option_type = "array"
		end
		default._array = nil
	end

	local option = {
		index = option_index,
		type = option_type,
		key = key,
		default = default,

		description = description,
		pad_before = pad_before,
	}

	self.options_list[option_index] = option

	-- table-options are just containers for sub-options and have no value
	if option_type == "table" then
		option.default = nil

		-- Add sub-options
		for i, sub_option_data in ipairs(default) do
			local sub_key = sub_option_data[1]
			sub_option_data[1] = key .. "." .. sub_key
			local sub_option = self:add_option(unpack(sub_option_data))
		end
	end

	if key then
		self.options[key] = option
		self.default_profile.values[option.key] = option.default
	end

	return option
end

function OptionParser:add_options(list_of_options)
	for i, option_args in ipairs(list_of_options) do
		self:add_option(unpack(option_args))
	end
end

function OptionParser:restore_defaults()
	for key, option in pairs(self.options) do
		if option.type ~= "table" then
			self.active_profile.values[option.key] = option.default
		end
	end
end

function OptionParser:restore_loaded()
	for key, option in pairs(self.options) do
		if option.type ~= "table" then
			-- Non-default profiles will have an .loaded entry for all options
			local value = self.active_profile.loaded[option.key]
			if value == nil then
				value = option.default
			end
			self.active_profile.values[option.key] = value
		end
	end
end

function OptionParser:_get_config_file(identifier)
	local config_filename = "script-opts/" .. identifier .. ".conf"
	local config_file = mp.find_config_file(config_filename)

	if not config_file then
		config_filename = "script-opts/" .. identifier .. ".conf"
		config_file = mp.find_config_file(config_filename)

		if config_file then
			msg.warn("lua-settings/ is deprecated, use directory script-opts/")
		end
	end

	return config_file
end

function OptionParser:value_to_string(value)
	if type(value) == "boolean" then
		if value then
			value = "yes"
		else
			value = "no"
		end
	elseif type(value) == "table" then
		return utils.format_json(value)
	end
	return tostring(value)
end

function OptionParser:string_to_value(option_type, value)
	if option_type == "boolean" then
		if value == "yes" or value == "true" then
			value = true
		elseif value == "no" or value == "false" then
			value = false
		else
			-- can't parse as boolean
			value = nil
		end
	elseif option_type == "number" then
		value = tonumber(value)
		if value == nil then
			-- Can't parse as number
		end
	elseif option_type == "array" then
		value = utils.parse_json(value)
	end
	return value
end

function OptionParser:get_profile(profile_name)
	for i, profile in ipairs(self.profiles) do
		if profile.name == profile_name then
			return profile
		end
	end
end

function OptionParser:create_profile(profile_name, base_on_original)
	if not self:get_profile(profile_name) then
		new_profile = { name = profile_name, values = {}, loaded = {}, config_lines = {} }

		if base_on_original then
			-- Copy values from default config
			for k, v in pairs(self.default_profile.values) do
				new_profile.values[k] = v
			end
			for k, v in pairs(self.default_profile.loaded) do
				new_profile.loaded[k] = v
			end
		else
			-- Copy current values, but not loaded
			for k, v in pairs(self.active_profile.values) do
				new_profile.values[k] = v
			end
		end

		table.insert(self.profiles, new_profile)
		return new_profile
	end
end

function OptionParser:load_options()
	if not self.config_file then
		return
	end
	local file = io.open(self.config_file, "r")
	if not file then
		return
	end

	local trim = function(text)
		return (text:gsub("^%s*(.-)%s*$", "%1"))
	end

	local current_profile = self.default_profile
	local override_reached = false
	local line_index = 1

	-- Read all lines in advance
	local lines = {}
	for line in file:lines() do
		table.insert(lines, line)
	end
	file:close()

	local total_lines = #lines

	while line_index < total_lines + 1 do
		local line = lines[line_index]

		local profile_name = line:match("^%[(..-)%]$")

		if line == self.OVERRIDE_START then
			override_reached = true
		elseif line:find("#") == 1 then
		-- Skip comments
		elseif profile_name then
			current_profile = self:get_profile(profile_name) or self:create_profile(profile_name, true)
			override_reached = false
		else
			local key, value = line:match("^(..-)=(.+)$")
			if key then
				key = trim(key)
				value = trim(value)

				local option = self.options[key]
				if not option then
					msg.warn(("%s:%d ignoring unknown key '%s'"):format(self.config_file, line_index, key))
				elseif option.type == "table" then
					msg.warn(("%s:%d ignoring value for table-option %s"):format(self.config_file, line_index, key))
				else
					-- If option is an array, make sure we read all lines
					if option.type == "array" then
						local start_index = line_index
						-- Read lines until one ends with ]
						while not value:match("%]%s*$") do
							line_index = line_index + 1
							if line_index > total_lines then
								msg.error(
									("%s:%d non-ending %s for key '%s'"):format(
										self.config_file,
										start_index,
										option.type,
										key
									)
								)
							end
							value = value .. trim(lines[line_index])
						end
					end
					local parsed_value = self:string_to_value(option.type, value)

					if parsed_value == nil then
						msg.error(
							("%s:%d error parsing value '%s' for key '%s' (as %s)"):format(
								self.config_file,
								line_index,
								value,
								key,
								option.type
							)
						)
					else
						current_profile.values[option.key] = parsed_value
						if not override_reached then
							current_profile.loaded[option.key] = parsed_value
						end
					end
				end
			end
		end

		if not override_reached and not profile_name then
			table.insert(current_profile.config_lines, line)
		end

		line_index = line_index + 1
	end
end

function OptionParser:save_options()
	if not self.config_file then
		return nil, "no configuration file found"
	end

	local file = io.open(self.config_file, "w")
	if not file then
		return nil, "unable to open configuration file for writing"
	end

	local profiles = { self.default_profile }
	for i, profile in ipairs(self.profiles) do
		table.insert(profiles, profile)
	end

	local out_lines = {}

	local add_linebreak = function()
		if out_lines[#out_lines] ~= "" then
			table.insert(out_lines, "")
		end
	end

	for profile_index, profile in ipairs(profiles) do
		local profile_override_lines = {}
		for option_index, option in ipairs(self.options_list) do
			local option_value = profile.values[option.key]
			local option_loaded = profile.loaded[option.key]

			if option_loaded == nil then
				option_loaded = self.default_profile.loaded[option.key]
			end
			if option_loaded == nil then
				option_loaded = option.default
			end

			-- If value is different from default AND loaded value, store it in array
			if option.key then
				if option_value ~= option_loaded then
					table.insert(
						profile_override_lines,
						("%s=%s"):format(option.key, self:value_to_string(option_value))
					)
				end
			end
		end

		if (#profile.config_lines > 0 or #profile_override_lines > 0) and profile ~= self.default_profile then
			-- Write profile name, if this is not default profile
			add_linebreak()
			table.insert(out_lines, ("[%s]"):format(profile.name))
		end

		-- Write original config lines
		for line_index, line in ipairs(profile.config_lines) do
			table.insert(out_lines, line)
		end
		-- end

		if #profile_override_lines > 0 then
			-- Add another newline before the override comment, if needed
			add_linebreak()

			table.insert(out_lines, self.OVERRIDE_START)
			for override_line_index, override_line in ipairs(profile_override_lines) do
				table.insert(out_lines, override_line)
			end
		end
	end

	-- Add a final linebreak if needed
	add_linebreak()

	file:write(table.concat(out_lines, "\n"))
	file:close()

	return true
end

function OptionParser:get_default_config_lines()
	local example_config_lines = {}

	for option_index, option in ipairs(self.options_list) do
		if option.pad_before then
			table.insert(example_config_lines, "")
		end

		if option.description then
			for description_line in option.description:gmatch("[^\r\n]+") do
				table.insert(example_config_lines, ("# " .. description_line))
			end
		end
		if option.key and option.type ~= "table" then
			table.insert(example_config_lines, ("%s=%s"):format(option.key, self:value_to_string(option.default)))
		end
	end
	return example_config_lines
end

function OptionParser:explain_options()
	local example_config_lines = self:get_default_config_lines()
	msg.info(table.concat(example_config_lines, "\n"))
end

function OptionParser:save_example_options(filename)
	local file = io.open(filename, "w")
	if not file then
		msg.error("Unable to open file '" .. filename .. "' for writing")
	else
		local example_config_lines = self:get_default_config_lines()
		file:write(table.concat(example_config_lines, "\n"))
		file:close()
		msg.info("Wrote example config to file '" .. filename .. "'")
	end
end
local SCRIPT_NAME = "mpv_crop_script"

local SCRIPT_KEYBIND = "c"
local SCRIPT_HANDLER = "crop-screenshot"

--------------------
-- Script options --
--------------------

local script_options = OptionParser(SCRIPT_NAME)
local option_values = script_options.values

script_options:add_options({
	{ nil, nil, "mpv_crop_script.lua options and default values" },
	{ nil, nil, "Output options #", true },
	{
		"output_template",
		"${filename}${!is_image: ${#pos:%02h.%02m.%06.3s}}${!full: ${crop_w}x${crop_h}} ${%unique:%03d}.${ext}",
		"Filename output template. See README.md for property expansion documentation.",
	},
	{
		nil,
		nil,
		[[Script-provided properties:
  filename    - filename without extension
  file_ext    - original extension without leading dot
  path        - original file path
  pos         - playback time
  ext         - output file extension without leading dot
  crop_w      - crop width
  crop_h      - crop height
  crop_x      - left
  crop_y      - top
  crop_x2     - right
  crop_y2     - bottom
  full        - boolean denoting a full (temporary) screenshot instead of crop
  is_image    - boolean denoting the source file is likely an image (zero duration and position)
  unique      - counter that will increase per each existing filename, until a unique name is found]],
	},

	{ "output_format", "png", "Format (encoder) to save final crops in. For example, png, mjpeg, targa, bmp" },
	{ "output_extension", "", "Output extension. Leave blank to try to choose from the encoder (if supported)" },

	{
		"create_directories",
		false,
		"Whether to create the directories in the final output path (defined by output_template)",
	},
	{
		"skip_screenshot_for_images",
		true,
		"If the current file is an image, skip taking a temporary screenshot and crop the image directly",
	},
	{ "keep_original", false, "Keep the full-sized temporary screenshot as well" },

	{ nil, nil, "Crop tool options #", true },
	{
		"overlay_transparency",
		160,
		"Transparency (0 - opaque, 255 - transparent) of the dim overlay on the non-cropped area",
	},
	{ "overlay_lightness", 0, "Ligthness (0 - black, 255 - white) of the dim overlay on the non-cropped area" },
	{ "draw_mouse", false, "Draw the crop crosshair" },
	{ "guide_type", "none", "Crop guide type. One of: none, grid, center" },
	{ "color_invert", false, "Use black lines instead of white for the crop frame and crosshair" },
	{
		"auto_invert",
		false,
		"Try to check if video is light or dark upon opening crop tool, and invert the colors if necessary",
	},

	{ nil, nil, "Misc options #", true },
	{
		"warn_about_template",
		true,
		"Warn about output_template missing ${ext}, to ensure the extension is not missing",
	},
	{ "disable_keybind", false, "Disable the built-in keybind" },
})

-- Read user-given options, if any
script_options:load_options()
--[[
  DisplayState keeps track of the current display state, and can
  handle mapping between video-space coords and display-space coords.
  Handles panscan and offsets and aligns and all that, following what
  mpv itself does (video/out/aspect.c).

  Does not depend on other libs.
]]
--

local DisplayState = {}
DisplayState.__index = DisplayState

setmetatable(DisplayState, {
	__call = function(cls, ...)
		return cls.new(...)
	end,
})

function DisplayState.new()
	local self = setmetatable({}, DisplayState)

	self:reset()

	return self
end

function DisplayState:reset()
	self.screen = {} -- Display (window, fullscreen) size
	self.video = {} -- Video size
	self.scale = {} -- video / screen
	self.bounds = {} -- Video rect within display

	self.screen_ready = false
	self.video_ready = false

	-- Stores internal display state (panscan, align, zoom etc)
	self.current_state = nil
end

function DisplayState:setup_events()
	mp.register_event("file-loaded", function()
		self:event_file_loaded()
	end)
end

function DisplayState:event_file_loaded()
	self:reset()
	self:recalculate_bounds(true)
end

-- Turns screen-space XY to video XY (can go negative)
function DisplayState:screen_to_video(x, y)
	local nx = (x - self.bounds.left) * self.scale.x
	local ny = (y - self.bounds.top) * self.scale.y
	return nx, ny
end

-- Turns video-space XY to screen XY
function DisplayState:video_to_screen(x, y)
	local nx = (x / self.scale.x) + self.bounds.left
	local ny = (y / self.scale.y) + self.bounds.top
	return nx, ny
end

function DisplayState:_collect_display_state()
	local screen_w, screen_h, screen_aspect = mp.get_osd_size()

	local state = {
		screen_w = screen_w,
		screen_h = screen_h,
		screen_aspect = screen_aspect,

		video_w = mp.get_property_native("dwidth"),
		video_h = mp.get_property_native("dheight"),

		video_w_raw = mp.get_property_native("video-out-params/w"),
		video_h_raw = mp.get_property_native("video-out-params/h"),

		panscan = mp.get_property_native("panscan"),
		video_zoom = mp.get_property_native("video-zoom"),
		video_unscaled = mp.get_property_native("video-unscaled"),

		video_align_x = mp.get_property_native("video-align-x"),
		video_align_y = mp.get_property_native("video-align-y"),

		video_pan_x = mp.get_property_native("video-pan-x"),
		video_pan_y = mp.get_property_native("video-pan-y"),

		fullscreen = mp.get_property_native("fullscreen"),
		keepaspect = mp.get_property_native("keepaspect"),
		keepaspect_window = mp.get_property_native("keepaspect-window"),
	}

	return state
end

function DisplayState:_state_changed(state)
	if self.current_state == nil then
		return true
	end

	for k in pairs(state) do
		if state[k] ~= self.current_state[k] then
			return true
		end
	end
	return false
end

function DisplayState:recalculate_bounds(forced)
	local new_state = self:_collect_display_state()
	if not (forced or self:_state_changed(new_state)) then
		-- Early out
		return self.screen_ready
	end
	self.current_state = new_state

	-- Store screen dimensions
	self.screen.width = new_state.screen_w
	self.screen.height = new_state.screen_h
	self.screen.ratio = new_state.screen_w / new_state.screen_h
	self.screen_ready = true

	-- Video dimensions
	if new_state.video_w and new_state.video_h then
		self.video.width = new_state.video_w
		self.video.height = new_state.video_h
		self.video.ratio = new_state.video_w / new_state.video_h

		-- This magic has been adapted from mpv's own video/out/aspect.c

		if new_state.keepaspect then
			local scaled_w, scaled_h = self:_aspect_calc_panscan(new_state)
			local video_left, video_right = self:_split_scaling(
				new_state.screen_w,
				scaled_w,
				new_state.video_zoom,
				new_state.video_align_x,
				new_state.video_pan_x
			)
			local video_top, video_bottom = self:_split_scaling(
				new_state.screen_h,
				scaled_h,
				new_state.video_zoom,
				new_state.video_align_y,
				new_state.video_pan_y
			)
			self.bounds = {
				left = video_left,
				right = video_right,

				top = video_top,
				bottom = video_bottom,

				width = video_right - video_left,
				height = video_bottom - video_top,
			}
		else
			self.bounds = {
				left = 0,
				top = 0,
				right = self.screen.width,
				bottom = self.screen.height,

				width = self.screen.width,
				height = self.screen.height,
			}
		end

		self.scale.x = new_state.video_w_raw / self.bounds.width
		self.scale.y = new_state.video_h_raw / self.bounds.height

		self.video_ready = true
	end

	return self.screen_ready
end

function DisplayState:_aspect_calc_panscan(state)
	-- From video/out/aspect.c
	local f_width = state.screen_w
	local f_height = (state.screen_w / state.video_w) * state.video_h

	if f_height > state.screen_h or f_height < state.video_h_raw then
		local tmp_w = (state.screen_h / state.video_h) * state.video_w
		if tmp_w <= state.screen_w then
			f_height = state.screen_h
			f_width = tmp_w
		end
	end

	local vo_panscan_area = state.screen_h - f_height

	local f_w = f_width / f_height
	local f_h = 1
	if vo_panscan_area == 0 then
		vo_panscan_area = state.screen_w - f_width
		f_w = 1
		f_h = f_height / f_width
	end

	if state.video_unscaled then
		vo_panscan_area = 0
		if
			state.video_unscaled ~= "downscale-big"
			or ((state.video_w <= state.screen_w) and (state.video_h <= state.screen_h))
		then
			f_width = state.video_w
			f_height = state.video_h
		end
	end

	local scaled_w = math.floor(f_width + vo_panscan_area * state.panscan * f_w)
	local scaled_h = math.floor(f_height + vo_panscan_area * state.panscan * f_h)
	return scaled_w, scaled_h
end

function DisplayState:_split_scaling(dst_size, scaled_src_size, zoom, align, pan)
	-- From video/out/aspect.c as well
	scaled_src_size = math.floor(scaled_src_size * 2 ^ zoom)
	align = (align + 1) / 2

	local dst_start = (dst_size - scaled_src_size) * align + pan * scaled_src_size
	local dst_end = dst_start + scaled_src_size

	-- We don't actually want these - we want to go out of bounds!
	-- dst_start = math.max(0, dst_start)
	-- dst_end = math.min(dst_size, dst_end)

	return math.floor(dst_start), math.floor(dst_end)
end
--[[
  ASSCropper is a tool to get crop values with a visual tool
  that handles mouse clicks and drags to manipulate a crop box,
  with a crosshair, guides, etc.

  Indirectly depends on DisplayState (as a given instance).
]]
--

local ASSCropper = {}
ASSCropper.__index = ASSCropper

setmetatable(ASSCropper, {
	__call = function(cls, ...)
		return cls.new(...)
	end,
})

function ASSCropper.new(display_state)
	local self = setmetatable({}, ASSCropper)
	local script_name = mp.get_script_name()
	self.keybind_group = script_name .. "_asscropper_binds"
	self.cropdetect_label = script_name .. "_asscropper_cropdetect"
	self.blackframe_label = script_name .. "_asscropper_blackframe"
	self.crop_label = script_name .. "_asscropper_crop"

	self.display_state = display_state

	self.tick_callback = nil
	self.tick_timer = mp.add_periodic_timer(1 / 60, function()
		if self.tick_callback then
			self.tick_callback()
		end
	end)
	self.tick_timer:stop()

	self.text_size = 18

	self.overlay_transparency = 160
	self.overlay_lightness = 0

	self.corner_size = 40
	self.corner_required_size = self.corner_size * 3

	self.guide_type_names = {
		[0] = "No guides",
		[1] = "Grid guides",
		[2] = "Center guides",
	}
	self.guide_type_count = 3

	self.default_options = {
		even_dimensions = false,
		guide_type = 0,
		draw_mouse = false,
		draw_help = true,
		color_invert = false,
		auto_invert = false,
	}
	self.options = default_options

	self.active = false

	self.mouse_screen = { x = 0, y = 0 }
	self.mouse_video = { x = 0, y = 0 }

	-- Crop in video-space
	self.current_crop = nil

	self.dragging = 0
	self.drag_start = { x = 0, y = 0 }
	self.restrict_ratio = false

	self.testing_crop = false

	self.detecting_crop = nil
	self.cropdetect_wait = nil
	self.cropdetect_timeout = nil

	self.detecting_blackframe = nil
	self.blackframe_wait = nil
	self.blackframe_timeout = nil

	self.nudges = {
		NUDGE_LEFT = { -1, 0, -1, 0 },
		NUDGE_UP = { 0, -1, 0, -1 },
		NUDGE_RIGHT = { 1, 0, 1, 0 },
		NUDGE_DOWN = { 0, 1, 0, 1 },
	}

	self.resizes = {
		SHRINK_LEFT = { 1, 0, 0, 0 },
		SHRINK_TOP = { 0, 1, 0, 0 },
		SHRINK_RIGHT = { 0, 0, -1, 0 },
		SHRINK_BOT = { 0, 0, 0, -1 },

		GROW_LEFT = { -1, 0, 0, 0 },
		GROW_TOP = { 0, -1, 0, 0 },
		GROW_RIGHT = { 0, 0, 1, 0 },
		GROW_BOT = { 0, 0, 0, 1 },
	}

	self._key_binds = {
		{
			"mouse_move",
			function()
				self:update_mouse_position()
			end,
		},
		{
			"mouse_btn0",
			function(e)
				self:on_mouse("mouse_btn0", e)
			end,
			{ complex = true },
		},
		{
			"shift+mouse_btn0",
			function(e)
				self:on_mouse("mouse_btn0", e, true)
			end,
			{ complex = true },
		},

		{
			"ctrl+shift+c",
			function()
				self:key_event("CROSSHAIR")
			end,
		},
		{
			"ctrl+shift+d",
			function()
				self:key_event("CROP_DETECT")
			end,
		},
		{
			"ctrl+shift+x",
			function()
				self:key_event("GUIDES")
			end,
		},
		{
			"ctrl+shift+t",
			function()
				self:key_event("TEST")
			end,
		},
		{
			"ctrl+shift+z",
			function()
				self:key_event("INVERT")
			end,
		},

		{
			"shift+left",
			function()
				self:key_event("NUDGE_LEFT")
			end,
			{ repeatable = true },
		},
		{
			"shift+up",
			function()
				self:key_event("NUDGE_UP")
			end,
			{ repeatable = true },
		},
		{
			"shift+right",
			function()
				self:key_event("NUDGE_RIGHT")
			end,
			{ repeatable = true },
		},
		{
			"shift+down",
			function()
				self:key_event("NUDGE_DOWN")
			end,
			{ repeatable = true },
		},

		{
			"ctrl+left",
			function()
				self:key_event("GROW_LEFT")
			end,
			{ repeatable = true },
		},
		{
			"ctrl+up",
			function()
				self:key_event("GROW_TOP")
			end,
			{ repeatable = true },
		},
		{
			"ctrl+right",
			function()
				self:key_event("SHRINK_LEFT")
			end,
			{ repeatable = true },
		},
		{
			"ctrl+down",
			function()
				self:key_event("SHRINK_TOP")
			end,
			{ repeatable = true },
		},

		{
			"ctrl+shift+left",
			function()
				self:key_event("SHRINK_RIGHT")
			end,
			{ repeatable = true },
		},
		{
			"ctrl+shift+up",
			function()
				self:key_event("SHRINK_BOT")
			end,
			{ repeatable = true },
		},
		{
			"ctrl+shift+right",
			function()
				self:key_event("GROW_RIGHT")
			end,
			{ repeatable = true },
		},
		{
			"ctrl+shift+down",
			function()
				self:key_event("GROW_BOT")
			end,
			{ repeatable = true },
		},

		{
			"ENTER",
			function()
				self:key_event("ENTER")
			end,
		},
		{
			"ESC",
			function()
				self:key_event("ESC")
			end,
		},
	}

	self._keys_bound = false

	for k, v in pairs(self._key_binds) do
		-- Insert a key name into the tables
		table.insert(v, 2, self.keybind_group .. "_key_" .. v[1])
	end

	return self
end

function ASSCropper:enable_key_bindings()
	if not self._keys_bound then
		for k, v in pairs(self._key_binds) do
			mp.add_forced_key_binding(unpack(v))
		end
		-- Clear "allow-vo-dragging"
		mp.input_enable_section("input_forced_" .. mp.script_name)
		self._keys_bound = true
	end
end

function ASSCropper:disable_key_bindings()
	for k, v in pairs(self._key_binds) do
		mp.remove_key_binding(v[2]) -- remove by name
	end
	self._keys_bound = false
end

function ASSCropper:finalize_crop()
	if self.current_crop ~= nil then
		local x1, x2 = self.current_crop[1].x, self.current_crop[2].x
		local y1, y2 = self.current_crop[1].y, self.current_crop[2].y

		self.current_crop.x, self.current_crop.y = x1, y1
		self.current_crop.w, self.current_crop.h = x2 - x1, y2 - y1

		if self.options.even_dimensions then
			self.current_crop.w = self.current_crop.w - (self.current_crop.w % 2)
			self.current_crop.h = self.current_crop.h - (self.current_crop.h % 2)
		end

		self.current_crop.x1, self.current_crop.x2 = x1, x1 + self.current_crop.w
		self.current_crop.y1, self.current_crop.y2 = y1, y1 + self.current_crop.h

		self.current_crop[2].x, self.current_crop[2].y = self.current_crop.x2, self.current_crop.y2
	end
end

function ASSCropper:key_event(name)
	if name == "ENTER" then
		self:stop_crop(false)

		self:finalize_crop()

		if self.callback_on_crop == nil then
			mp.set_osd_ass(0, 0, "")
		else
			self.callback_on_crop(self.current_crop)
		end
	elseif name == "ESC" then
		self:stop_crop(true)

		if self.callback_on_cancel == nil then
			mp.set_osd_ass(0, 0, "")
		else
			self.callback_on_cancel()
		end
	elseif name == "TEST" then
		self:toggle_testing()
	elseif not self.testing_crop then
		if name == "CROP_DETECT" then
			self:toggle_crop_detect()
		elseif name == "CROSSHAIR" then
			self.options.draw_mouse = not self.options.draw_mouse
		elseif name == "INVERT" then
			self.options.color_invert = not self.options.color_invert
		elseif name == "GUIDES" then
			self.options.guide_type = (self.options.guide_type + 1) % self.guide_type_count
			mp.osd_message(self.guide_type_names[self.options.guide_type])
		elseif self.nudges[name] then
			self:nudge(true, unpack(self.nudges[name]))
		elseif self.resizes[name] then
			self:nudge(false, unpack(self.resizes[name]))
		end
	end
end

function ASSCropper:nudge(keep_size, left, top, right, bottom)
	if self.current_crop == nil then
		return
	end

	local x1, y1 = self.current_crop[1].x, self.current_crop[1].y
	local x2, y2 = self.current_crop[2].x, self.current_crop[2].y

	local w, h = x2 - x1, y2 - y1
	if not keep_size then
		w, h = 0, 0

		if self.options.even_dimensions then
			left = left * 2
			top = top * 2
			right = right * 2
			bottom = bottom * 2
		end
	end

	local vw, vh = self.display_state.video.width, self.display_state.video.height

	x1 = math.max(0, math.min(vw - w, x1 + left))
	y1 = math.max(0, math.min(vh - h, y1 + top))

	x2 = math.max(w, math.min(vw, x2 + right))
	y2 = math.max(h, math.min(vh, y2 + bottom))

	local x_offset = math.max(0, 0 - x1) - math.max(0, x2 - vw)
	local y_offset = math.max(0, 0 - y1) - math.max(0, y2 - vh)

	x1 = x1 + x_offset
	y1 = y1 + y_offset
	x2 = x2 + x_offset
	y2 = y2 + y_offset

	self.current_crop[1].x, self.current_crop[2].x = order_pair(x1, x2)
	self.current_crop[1].y, self.current_crop[2].y = order_pair(y1, y2)
end

function ASSCropper:blackframe_stop()
	if self.detecting_blackframe then
		self.detecting_blackframe:stop()
		self.detecting_blackframe = nil

		local filters = mp.get_property_native("vf")
		for i, filter in ipairs(filters) do
			if filter.label == self.blackframe_label then
				table.remove(filters, i)
			end
		end
		mp.set_property_native("vf", filters)
	end
end

function ASSCropper:toggle_testing()
	if self.testing_crop then
		self:stop_testing()
	else
		self:start_testing()
	end
end

function ASSCropper:start_testing()
	if not self.testing_crop then
		local cw = self.current_crop and (self.current_crop[2].x - self.current_crop[1].x) or 0
		local ch = self.current_crop and (self.current_crop[2].y - self.current_crop[1].y) or 0

		if cw == 0 or ch == 0 then
			return mp.osd_message("Can't test current crop")
		end

		self:cropdetect_stop()
		self:blackframe_stop()

		local crop_filter = ("@%s:crop=w=%d:h=%d:x=%d:y=%d"):format(
			self.crop_label,
			cw,
			ch,
			self.current_crop[1].x,
			self.current_crop[1].y
		)
		local ret = mp.commandv("vf", "add", crop_filter)
		if ret then
			self.testing_crop = true
		end
	end
end

function ASSCropper:stop_testing()
	if self.testing_crop then
		local filters = mp.get_property_native("vf")
		for i, filter in ipairs(filters) do
			if filter.label == self.crop_label then
				table.remove(filters, i)
			end
		end
		mp.set_property_native("vf", filters)
		self.testing_crop = false
	end
end

function ASSCropper:blackframe_check()
	local blackframe_metadata = mp.get_property_native("vf-metadata/" .. self.blackframe_label)
	local black_percentage = tonumber(blackframe_metadata["lavfi.blackframe.pblack"])

	local now = mp.get_time()
	if black_percentage ~= nil and now >= self.blackframe_wait then
		self:blackframe_stop()

		self.options.color_invert = black_percentage < 50
	elseif now > self.blackframe_timeout then
		-- Couldn't get blackframe metadata in time!
		self:blackframe_stop()
	end
end

function ASSCropper:blackframe_start()
	self:blackframe_stop()
	if not self.detecting_blackframe then
		local blackframe_filter = ("@%s:blackframe=amount=%d:threshold=%d"):format(self.blackframe_label, 0, 128)

		local ret = mp.commandv("vf", "add", blackframe_filter)
		if ret then
			self.blackframe_wait = mp.get_time() + 0.15
			self.blackframe_timeout = self.blackframe_wait + 1

			self.detecting_blackframe = mp.add_periodic_timer(1 / 10, function()
				self:blackframe_check()
			end)
		end
	end
end

function ASSCropper:cropdetect_stop()
	if self.detecting_crop then
		self.detecting_crop:stop()
		self.detecting_crop = nil
		self.cropdetect_wait = nil
		self.cropdetect_timeout = nil

		local filters = mp.get_property_native("vf")
		for i, filter in ipairs(filters) do
			if filter.label == self.cropdetect_label then
				table.remove(filters, i)
			end
		end
		mp.set_property_native("vf", filters)
	end
end

function ASSCropper:cropdetect_check()
	local cropdetect_metadata = mp.get_property_native("vf-metadata/" .. self.cropdetect_label)
	local get_n = function(s)
		return tonumber(cropdetect_metadata["lavfi.cropdetect." .. s])
	end

	local now = mp.get_time()
	if not isempty(cropdetect_metadata) and now >= self.cropdetect_wait then
		self:cropdetect_stop()

		self.current_crop = {
			{ x = get_n("x1"), y = get_n("y1") },
			{ x = get_n("x2") + 1, y = get_n("y2") + 1 },
		}

		mp.osd_message("Crop detected")
	elseif now > self.cropdetect_timeout then
		mp.osd_message("Crop detect timed out")
		self:cropdetect_stop()
	end
end

function ASSCropper:toggle_crop_detect()
	if self.detecting_crop then
		self:cropdetect_stop()
		mp.osd_message("Cancelled crop detect")
	else
		local cropdetect_filter = ("@%s:cropdetect=limit=%f:round=2:reset=0"):format(self.cropdetect_label, 30 / 255)

		local ret = mp.commandv("vf", "add", cropdetect_filter)
		if not ret then
			mp.osd_message("Crop detect failed")
		else
			self.cropdetect_wait = mp.get_time() + 0.2
			self.cropdetect_timeout = self.cropdetect_wait + 1.5

			mp.osd_message("Starting automatic crop detect")
			self.detecting_crop = mp.add_periodic_timer(1 / 10, function()
				self:cropdetect_check()
			end)
		end
	end
end

function ASSCropper:start_crop(options, on_crop, on_cancel)
	-- Refresh display state
	self.display_state:recalculate_bounds(true)
	if self.display_state.video_ready then
		self.active = true
		self.tick_timer:resume()

		self.options = {}

		for k, v in pairs(self.default_options) do
			self.options[k] = v
		end
		for k, v in pairs(options or {}) do
			self.options[k] = v
		end

		self.callback_on_crop = on_crop
		self.callback_on_cancel = on_cancel

		self.dragging = 0

		self:enable_key_bindings()
		self:update_mouse_position()

		if self.options.auto_invert then
			self:blackframe_start()
		end
	end
end

function ASSCropper:stop_crop(clear)
	self.active = false
	self.tick_timer:stop()

	self:cropdetect_stop()
	self:blackframe_stop()
	self:stop_testing()

	self:disable_key_bindings()
	if clear then
		self.current_crop = nil
	end
end

function ASSCropper:on_tick()
	-- Unused, for debugging
	if self.active then
		self.display_state:recalculate_bounds()
		self:render()
	end
end

function ASSCropper:update_mouse_position()
	-- These are real on-screen coords.
	self.mouse_screen.x, self.mouse_screen.y = mp.get_mouse_pos()

	if self.display_state:recalculate_bounds() and self.display_state.video_ready then
		-- These are on-video coords.
		local mx, my = self.display_state:screen_to_video(self.mouse_screen.x, self.mouse_screen.y)
		self.mouse_video.x = mx
		self.mouse_video.y = my
	end
end

function ASSCropper:get_hitboxes(crop_box)
	crop_box = crop_box or self.current_crop
	if crop_box == nil then
		return nil
	end

	local x1, x2 = order_pair(crop_box[1].x, crop_box[2].x)
	local y1, y2 = order_pair(crop_box[1].y, crop_box[2].y)
	local w, h = math.abs(x2 - x1), math.abs(y2 - y1)

	-- Corner and required corner size in videospace pixels
	local mult = math.min(self.display_state.scale.x, self.display_state.scale.y)
	local videospace_corner_size = self.corner_size * mult
	local videospace_required_size = self.corner_required_size * mult

	local handles_outside = (math.min(w, h) <= videospace_required_size)

	local hitbox_bases = {
		{ x1, y2, x1, y2 }, -- BL
		{ x1, y2, x2, y2 }, -- B
		{ x2, y2, x2, y2 }, -- BR

		{ x1, y1, x1, y2 }, -- L
		{ x1, y1, x2, y2 }, -- Center
		{ x2, y1, x2, y2 }, -- R

		{ x1, y1, x1, y1 }, -- TL
		{ x1, y1, x2, y1 }, -- T
		{ x2, y1, x2, y1 }, -- TR
	}

	local hitbox_mults
	if handles_outside then
		hitbox_mults = {
			{ -1, 0, 0, 1 },
			{ 0, 0, 0, 1 },
			{ 0, 0, 1, 1 },

			{ -1, 0, 0, 0 },
			{ 0, 0, 0, 0 },
			{ 0, 0, 1, 0 },

			{ -1, -1, 0, 0 },
			{ 0, -1, 0, 0 },
			{ 0, -1, 1, 0 },
		}
	else
		hitbox_mults = {
			{ 0, -1, 1, 0 },
			{ 1, -1, -1, 0 },
			{ -1, -1, 0, 0 },

			{ 0, 1, 1, -1 },
			{ 1, 1, -1, -1 },
			{ -1, 1, 0, -1 },

			{ 0, 0, 1, 1 },
			{ 1, 0, -1, 1 },
			{ -1, 0, 0, 1 },
		}
	end

	local hitboxes = {}
	for index, hitbox_base in ipairs(hitbox_bases) do
		local hitbox_mult = hitbox_mults[index]

		hitboxes[index] = {
			hitbox_base[1] + hitbox_mult[1] * videospace_corner_size,
			hitbox_base[2] + hitbox_mult[2] * videospace_corner_size,
			hitbox_base[3] + hitbox_mult[3] * videospace_corner_size,
			hitbox_base[4] + hitbox_mult[4] * videospace_corner_size,
		}
	end
	-- Pseudobox to easily pass the original crop box
	hitboxes[10] = { x1, y1, x2, y2 }

	return hitboxes
end

function ASSCropper:hit_test(hitboxes, position)
	if hitboxes == nil then
		return 0
	else
		local px, py = position.x, position.y

		for i = 1, 9 do
			local hb = hitboxes[i]

			if (px >= hb[1] and px < hb[3]) and (py >= hb[2] and py < hb[4]) then
				return i
			end
		end
		-- No hits
		return 0
	end
end

function ASSCropper:on_mouse(button, event, shift_down)
	if not (event.event == "up" or event.event == "down") then
		return
	end
	mouse_down = event.event == "down"
	shift_down = shift_down or false

	if button == "mouse_btn0" and self.active and not self.detecting_crop and not self.testing_crop then
		local mouse_pos = { x = self.mouse_video.x, y = self.mouse_video.y }

		-- Helpers
		local xy_same = function(a, b)
			return a.x == b.x and a.y == b.y
		end
		local xy_distance = function(a, b)
			local dx = a.x - b.x
			local dy = a.y - b.y
			return math.sqrt(dx * dx + dy * dy)
		end
		--

		if mouse_down then -- Mouse pressed
			local bound_mouse_pos = {
				x = math.max(0, math.min(self.display_state.video.width, mouse_pos.x)),
				y = math.max(0, math.min(self.display_state.video.height, mouse_pos.y)),
			}

			if self.current_crop == nil then
				self.current_crop = { bound_mouse_pos, bound_mouse_pos }

				self.dragging = 3
				self.anchor_pos = { bound_mouse_pos.x, bound_mouse_pos.y }

				self.crop_ratio = 1
				self.drag_start = bound_mouse_pos

				local handle_pos = self:_get_anchor_positions()[hit]
				self.drag_offset = { 0, 0 }

				self.restrict_ratio = shift_down
			elseif self.dragging == 0 then
				-- Check if we drag from a handle
				local hitboxes = self:get_hitboxes()
				local hit = self:hit_test(hitboxes, mouse_pos)

				self.dragging = hit
				self.anchor_pos = self:_get_anchor_positions()[10 - hit]

				self.crop_ratio = (hitboxes[10][3] - hitboxes[10][1]) / (hitboxes[10][4] - hitboxes[10][2])
				self.drag_start = mouse_pos

				local handle_pos = self:_get_anchor_positions()[hit] or { mouse_pos.x, mouse_pos.y }
				self.drag_offset = { mouse_pos.x - handle_pos[1], mouse_pos.y - handle_pos[2] }

				self.restrict_ratio = shift_down

				-- Start a new drag if not on handle
				if self.dragging == 0 then
					self.current_crop = { bound_mouse_pos, bound_mouse_pos }
					self.crop_ratio = 1

					self.dragging = 3
					self.anchor_pos = { bound_mouse_pos.x, bound_mouse_pos.y }
					-- self.drag_start = mouse_pos
				end
			end
		else -- Mouse released
			if
				xy_same(self.current_crop[1], self.current_crop[2])
				and xy_distance(self.current_crop[1], mouse_pos) < 5
			then
			-- Mouse released after first click - ignore
			elseif self.dragging > 0 then
				-- Adjust current crop
				self.current_crop = self:offset_crop_by_drag()
				self.dragging = 0
			end
		end
	end
end

function ASSCropper:_get_anchor_positions()
	local x1, y1 = self.current_crop[1].x, self.current_crop[1].y
	local x2, y2 = self.current_crop[2].x, self.current_crop[2].y
	return {
		[1] = { x1, y2 },
		[2] = { (x1 + x2) / 2, y2 },
		[3] = { x2, y2 },

		[4] = { x1, (y1 + y2) / 2 },
		[5] = { (x1 + x2) / 2, (y1 + y2) / 2 },
		[6] = { x2, (y1 + y2) / 2 },

		[7] = { x1, y1 },
		[8] = { (x1 + x2) / 2, y1 },
		[9] = { x2, y1 },
	}
end

function ASSCropper:offset_crop_by_drag()
	-- Here be dragons lol
	local vw, vh = self.display_state.video.width, self.display_state.video.height
	local mx, my = self.mouse_video.x, self.mouse_video.y

	local x1, x2 = self.current_crop[1].x, self.current_crop[2].x
	local y1, y2 = self.current_crop[1].y, self.current_crop[2].y

	local anchor_positions = self:_get_anchor_positions()

	local handle = self.dragging
	if handle > 0 then
		local ax, ay = self.anchor_pos[1], self.anchor_pos[2]

		local ox, oy = self.drag_offset[1], self.drag_offset[2]

		local dx, dy = mx - ax - ox, my - ay - oy

		-- Select active corner
		if handle % 2 == 1 and handle ~= 5 then -- Change corners 4/6, 2/8
			handle = (mx - ox < ax) and 1 or 3
			handle = handle + ((my - oy < ay) and 6 or 0)
		else -- Change edges 1, 3, 7, 9
			if handle == 4 and mx - ox > ax then
				handle = 6
			elseif handle == 6 and mx - ox < ax then
				handle = 4
			elseif handle == 2 and my - oy < ay then
				handle = 8
			elseif handle == 8 and my - oy > ay then
				handle = 2
			end
		end

		-- Handle booleans for logic
		local h_bot = handle >= 1 and handle <= 3
		local h_top = handle >= 7 and handle <= 9
		local h_left = (handle - 1) % 3 == 0
		local h_right = handle % 3 == 0

		local h_horiz = handle == 4 or handle == 6
		local h_vert = handle == 2 or handle == 8

		-- Keep rect aspect ratio
		if self.restrict_ratio then
			local adx, ady = math.abs(dx), math.abs(dy)

			-- Fit rect to mouse
			local tmpy = adx / self.crop_ratio
			if tmpy < ady then
				adx = ady * self.crop_ratio
			else
				ady = tmpy
			end

			-- Figure out max size for corners, limit adx/ady
			local max_w, max_h = vw, vh

			if h_bot then
				max_h = vh - ay -- Max height is from anchor to video bottom
			elseif h_top then
				max_h = ay -- Max height is from video bottom to anchor
			elseif h_horiz then
				-- Max height is closest edge * 2
				max_h = math.min(vh - ay, ay) * 2
			end

			if h_left then
				max_w = ax
			elseif h_right then
				max_w = vw - ax
			elseif h_vert then
				max_w = math.min(vw - ax, ax) * 2
			end

			-- Limit size to corners
			if handle ~= 5 then
				-- TODO this can be done tidier?

				-- If wider than max width, scale down
				if adx > max_w then
					adx = max_w
					ady = adx / self.crop_ratio
				end
				-- If taller than max height, scale down
				if ady > max_h then
					ady = max_h
					adx = ady * self.crop_ratio
				end
			end

			-- Hacky offsets
			if handle == 1 then
				dx = -adx
				dy = ady
			elseif handle == 2 then
				dx = adx
				dy = ady
			elseif handle == 3 then
				dx = adx
				dy = ady
			elseif handle == 4 then
				dx = -adx
				dy = ady
			elseif handle == 5 then
			-- pass
			elseif handle == 6 then
				dx = adx
				dy = ady
			elseif handle == 7 then
				dy = -ady
				dx = -adx
			elseif handle == 8 then
				dx = adx
				dy = -ady
			elseif handle == 9 then
				dx = adx
				dy = -ady
			end
		end

		-- Can this be done not-manually?
		-- Re-create the rect with some corners anchored etc
		if handle == 5 then
			-- Simply move the box around
			x1, x2 = x1 + dx, x2 + dx
			y1, y2 = y1 + dy, y2 + dy
		elseif handle == 1 then
			x1, x2 = ax + dx, ax
			y1, y2 = ay, ay + dy
		elseif handle == 2 then
			y1, y2 = ay, ay + dy

			if self.restrict_ratio then
				x1, x2 = ax - dx / 2, ax + dx / 2
			end
		elseif handle == 3 then
			x1, x2 = ax, ax + dx
			y1, y2 = ay, ay + dy
		elseif handle == 4 then
			x1, x2 = ax + dx, ax

			if self.restrict_ratio then
				y1, y2 = ay - dy / 2, ay + dy / 2
			end
		elseif handle == 6 then
			x1, x2 = ax, ax + dx

			if self.restrict_ratio then
				y1, y2 = ay - dy / 2, ay + dy / 2
			end
		elseif handle == 7 then
			x1, x2 = ax + dx, ax
			y1, y2 = ay + dy, ay
		elseif handle == 8 then
			y1, y2 = ay + dy, ay

			if self.restrict_ratio then
				x1, x2 = ax - dx / 2, ax + dx / 2
			end
		elseif handle == 9 then
			x1, x2 = ax, ax + dx
			y1, y2 = ay + dy, ay
		end

		if self.dragging == 5 then
			-- On moving the entire box, we have to figure out how much to "offset" every corner if we go over the edge
			local x_min = math.max(0, 0 - x1)
			local y_min = math.max(0, 0 - y1)

			local x_max = math.max(0, x2 - vw)
			local y_max = math.max(0, y2 - vh)

			x1 = x1 + x_min - x_max
			y1 = y1 + y_min - y_max
			x2 = x2 + x_min - x_max
			y2 = y2 + y_min - y_max
		elseif not self.restrict_ratio then
			-- This is already done for restricted ratios, hence the if

			-- Constrict the crop to video space
			-- Since one corner/edge is moved at a time, we can just minmax this
			x1, x2 = math.max(0, x1), math.min(vw, x2)
			y1, y2 = math.max(0, y1), math.min(vh, y2)
		end
	end -- /drag

	if self.dragging > 0 and self.options.even_dimensions then
		local w, h = x2 - x1, y2 - y1
		local even_w = w - (w % 2)
		local even_h = h - (h % 2)

		if handle == 1 or handle == 2 or handle == 3 then
			y2 = y1 + even_h
		elseif handle == 7 or handle == 8 or handle == 9 then
			y1 = y2 - even_h
		end
		if handle == 1 or handle == 4 or handle == 7 then
			x1 = x2 - even_w
		elseif handle == 3 or handle == 6 or handle == 9 then
			x2 = x1 + even_w
		end
	end

	local fx1, fx2 = order_pair(math.floor(x1), math.floor(x2))
	local fy1, fy2 = order_pair(math.floor(y1), math.floor(y2))

	-- msg.info(fx1, fy1, fx2, fy2, handle)

	return { { x = fx1, y = fy1 }, { x = fx2, y = fy2 } }, handle
end

function order_pair(a, b)
	if a < b then
		return a, b
	else
		return b, a
	end
end

function ASSCropper:render()
	-- For debugging
	local ass_txt = self:get_render_ass()

	local ds = self.display_state
	mp.set_osd_ass(ds.screen.width, ds.screen.height, ass_txt)
end

function ASSCropper:get_render_ass(dim_only)
	if not self.display_state.video_ready then
		msg.info("No video info on display_state")
		return ""
	end

	line_color = self.options.color_invert and 20 or 220
	local guide_format = string.format(
		"{\\3a&HFF&\\3a&H%02X&\\3c&H%02X%02X%02X&\\bord1\\shad0}",
		128,
		line_color,
		line_color,
		line_color
	)

	ass = assdraw.ass_new()
	if self.current_crop then
		if self.testing_crop then
			-- Just draw simple help
			ass:new_event()
			ass:pos(self.display_state.screen.width - 5, 5)
			ass:append(string.format("{\\fs%d\\an%d\\bord2}", self.text_size, 9))

			local fmt_key = function(key, text)
				return string.format("[{\\c&HBEBEBE&}%s{\\c} %s]", key:upper(), text)
			end

			ass:append(
				fmt_key("ENTER", "Accept crop")
					.. " "
					.. fmt_key("ESC", "Cancel crop")
					.. "\\N"
					.. fmt_key("T", "Stop testing")
			)
			return ass.text
		end

		local temp_crop, drawn_handle = self:offset_crop_by_drag()
		local v_hb = self:get_hitboxes(temp_crop)
		-- Map coords to screen
		local s_hb = {}
		for index, coords in pairs(v_hb) do
			local x1, y1 = self.display_state:video_to_screen(coords[1], coords[2])
			local x2, y2 = self.display_state:video_to_screen(coords[3], coords[4])
			s_hb[index] = { x1, y1, x2, y2 }
		end

		-- Full crop
		local v_crop = v_hb[10] -- Video-space
		local s_crop = s_hb[10] -- Screen-space

		-- Inverse clipping for the crop box
		ass:new_event()
		ass:append(string.format("{\\iclip(%d,%d,%d,%d)}", s_crop[1], s_crop[2], s_crop[3], s_crop[4]))

		-- Dim overlay
		local format_dim = string.format(
			"{\\bord0\\1a&H%02X&\\1c&H%02X%02X%02X&}",
			self.overlay_transparency,
			self.overlay_lightness,
			self.overlay_lightness,
			self.overlay_lightness
		)
		ass:pos(0, 0)
		ass:draw_start()
		ass:append(format_dim)
		ass:rect_cw(0, 0, self.display_state.screen.width, self.display_state.screen.height)
		ass:draw_stop()

		if dim_only then -- Early out with just the dim outline
			return ass.text
		end

		if draw_text then
			-- Text on end
			ass:new_event()
			ass:pos(ce_x, ce_y)
			-- Text align
			local txt_a = ((ce_x > cs_x) and 3 or 1) + ((ce_y > cs_y) and 0 or 6)
			ass:an(txt_a)
			ass:append("{\\fs20\\shad0\\be0\\bord2}")
			ass:append(string.format("%dx%d", math.abs(ce_x - cs_x), math.abs(ce_y - cs_y)))
		end

		local box_format =
			string.format("{\\1a&HFF&\\3a&H%02X&\\3c&H%02X%02X%02X&\\bord1}", 0, line_color, line_color, line_color)
		local handle_hilight_format = string.format(
			"{\\1a&H%02X&\\3a&H%02X&\\3c&H%02X%02X%02X&\\bord0}",
			230,
			0,
			line_color,
			line_color,
			line_color
		)
		local handle_drag_format = string.format(
			"{\\1a&H%02X&\\3a&H%02X&\\3c&H%02X%02X%02X&\\bord1}",
			200,
			0,
			line_color,
			line_color,
			line_color
		)

		-- Main crop box
		ass:new_event()
		ass:pos(0, 0)
		ass:append(box_format)
		ass:draw_start()
		ass:rect_cw(s_crop[1], s_crop[2], s_crop[3], s_crop[4])
		ass:draw_stop()

		-- Guide grid, 3x3
		if self.options.guide_type then
			ass:new_event()
			ass:pos(0, 0)
			ass:append(guide_format)
			ass:draw_start()

			local w = (s_crop[3] - s_crop[1])
			local h = (s_crop[4] - s_crop[2])

			local w_3rd = w / 3
			local h_3rd = h / 3
			local w_2 = w / 2
			local h_2 = h / 2
			if self.options.guide_type == 1 then
				-- 3x3 grid
				ass:move_to(s_crop[1] + w_3rd, s_crop[2])
				ass:line_to(s_crop[1] + w_3rd, s_crop[4])

				ass:move_to(s_crop[1] + w_3rd * 2, s_crop[2])
				ass:line_to(s_crop[1] + w_3rd * 2, s_crop[4])

				ass:move_to(s_crop[1], s_crop[2] + h_3rd)
				ass:line_to(s_crop[3], s_crop[2] + h_3rd)

				ass:move_to(s_crop[1], s_crop[2] + h_3rd * 2)
				ass:line_to(s_crop[3], s_crop[2] + h_3rd * 2)
			elseif self.options.guide_type == 2 then
				-- Top to bottom
				ass:move_to(s_crop[1] + w_2, s_crop[2])
				ass:line_to(s_crop[1] + w_2, s_crop[4])

				-- Left to right
				ass:move_to(s_crop[1], s_crop[2] + h_2)
				ass:line_to(s_crop[3], s_crop[2] + h_2)
			end
			ass:draw_stop()
		end

		if self.dragging > 0 and drawn_handle ~= 5 then
			-- While dragging, draw only the dragging handle
			ass:new_event()
			ass:append(handle_drag_format)
			ass:pos(0, 0)
			ass:draw_start()
			ass:rect_cw(s_hb[drawn_handle][1], s_hb[drawn_handle][2], s_hb[drawn_handle][3], s_hb[drawn_handle][4])
			ass:draw_stop()
		elseif self.dragging == 0 then
			local hit_index = self:hit_test(s_hb, self.mouse_screen)
			if hit_index > 0 and hit_index ~= 5 then
				-- Hilight handle
				ass:new_event()
				ass:append(handle_hilight_format)
				ass:pos(0, 0)
				ass:draw_start()
				ass:rect_cw(s_hb[hit_index][1], s_hb[hit_index][2], s_hb[hit_index][3], s_hb[hit_index][4])
				ass:draw_stop()
			end

			ass:new_event()
			ass:pos(0, 0)
			ass:append(box_format)
			ass:draw_start()

			-- Draw corner handles
			for k, v in pairs({ 1, 3, 7, 9 }) do
				ass:rect_cw(s_hb[v][1], s_hb[v][2], s_hb[v][3], s_hb[v][4])
			end
			ass:draw_stop()
		end

		if true or draw_text then
			local br_pos = { s_crop[3] - 2, s_crop[4] + 2 }
			local br_align = 9
			if br_pos[2] >= self.display_state.screen.height - 20 then
				br_pos[2] = br_pos[2] - 4
				br_align = 3
			end

			ass:new_event()
			ass:pos(unpack(br_pos))
			ass:an(br_align)
			ass:append("{\\fs20\\shad0\\be0\\bord2}")
			ass:append(string.format("%dx%d", v_crop[3] - v_crop[1], v_crop[4] - v_crop[2]))

			local tl_pos = { s_crop[1] + 2, s_crop[2] - 2 }
			local tl_align = 1
			if tl_pos[2] < 20 then
				tl_pos[2] = tl_pos[2] + 4
				tl_align = 7
			end

			ass:new_event()
			ass:pos(unpack(tl_pos))
			ass:an(tl_align)
			ass:append("{\\fs20\\shad0\\be0\\bord2}")
			ass:append(string.format("%d,%d", v_crop[1], v_crop[2]))
		end

		ass:draw_stop()
	end

	-- Crosshair for mouse
	if self.options.draw_mouse and not dim_only then
		ass:new_event()
		ass:pos(0, 0)
		ass:append(guide_format)
		ass:draw_start()

		ass:move_to(self.mouse_screen.x, 0)
		ass:line_to(self.mouse_screen.x, self.display_state.screen.height)

		ass:move_to(0, self.mouse_screen.y)
		ass:line_to(self.display_state.screen.width, self.mouse_screen.y)

		ass:draw_stop()
	end

	if self.options.draw_help and not dim_only then
		ass:new_event()
		ass:pos(self.display_state.screen.width - 5, 5)
		local text_align = 9
		ass:append(string.format("{\\fs%d\\an%d\\bord2}", self.text_size, text_align))

		local fmt_key = function(key, text)
			return string.format("[{\\c&HBEBEBE&}%s{\\c} %s]", key:upper(), text)
		end

		local crosshair_txt = self.options.draw_mouse and "Hide" or "Show"
		lines = {
			fmt_key("ENTER", "Accept crop") .. " " .. fmt_key("ESC", "Cancel crop") .. " " .. fmt_key(
				"^D",
				"Autodetect crop"
			) .. " " .. fmt_key("^T", "Test crop"),
			fmt_key("SHIFT-Drag", "Constrain ratio") .. " " .. fmt_key("SHIFT-Arrow", "Nudge"),
			fmt_key("^C", crosshair_txt .. " crosshair") .. " " .. fmt_key("^X", "Cycle guides") .. " " .. fmt_key(
				"^Z",
				"Invert color"
			),
		}

		local full_line = nil
		for i, line in pairs(lines) do
			if line ~= nil then
				full_line = full_line and (full_line .. "\\N" .. line) or line
			end
		end
		ass:append(full_line)
	end

	return ass.text
end
--[[
  A tool to expand properties in template strings, mimicking mpv's
  property expansion but with a few extras (like formatting times).

  Depends on helpers.lua (isempty)
]]
--

local PropertyExpander = {}
PropertyExpander.__index = PropertyExpander

setmetatable(PropertyExpander, {
	__call = function(cls, ...)
		return cls.new(...)
	end,
})

function PropertyExpander.new(property_source)
	local self = setmetatable({}, PropertyExpander)
	self.sentinel = {}

	-- property_source is a table which defines the following functions:
	-- get_raw_property(name, def) - returns a raw property or def
	-- get_property(name) - returns a string
	-- get_property_osd(name) - returns an OSD formatted string (whatever that'll mean)
	self.property_source = property_source
	return self
end

-- Formats seconds to H:M:S based on a %h-%m-%s format
function PropertyExpander:_format_time(seconds, time_format)
	-- In case "seconds" is not a number, give it back
	if type(seconds) ~= "number" then
		return seconds
	end

	time_format = time_format or "%02h.%02m.%06.3s"

	local types = { h = "d", m = "d", s = "f", S = "f", M = "d" }
	local values = {
		h = math.floor(seconds / 3600),
		m = math.floor((seconds % 3600) / 60),
		s = (seconds % 60),
		S = seconds,
		M = math.floor((seconds % 1) * 1000),
	}

	local substitutor = function(sub_format, char)
		local v = values[char]
		local t = types[char]
		if t == nil then
			return nil
		end

		sub_format = "%" .. sub_format .. types[char]
		return v and sub_format:format(v) or nil
	end

	return time_format:gsub("%%([%-%+ #0]*%d*.?%d*)([%a%%])", substitutor)
end

-- Format a date
function PropertyExpander:_format_date(seconds, date_format)
	-- In case "seconds" is not nil or a number, give it back
	if type(seconds) ~= "number" and type(seconds) ~= "nil" then
		return seconds
	end

	--[[
    As stated by Lua docs:
    %a  abbreviated weekday name (e.g., Wed)
    %A  full weekday name (e.g., Wednesday)
    %b  abbreviated month name (e.g., Sep)
    %B  full month name (e.g., September)
    %c  date and time (e.g., 09/16/98 23:48:10)
    %d  day of the month (16) [01-31]
    %H  hour, using a 24-hour clock (23) [00-23]
    %I  hour, using a 12-hour clock (11) [01-12]
    %M  minute (48) [00-59]
    %m  month (09) [01-12]
    %p  either "am" or "pm" (pm)
    %S  second (10) [00-61]
    %w  weekday (3) [0-6 = Sunday-Saturday]
    %x  date (e.g., 09/16/98)
    %X  time (e.g., 23:48:10)
    %Y  full year (1998)
    %y  two-digit year (98) [00-99]
    %%  the character `%´
  ]]
	--
	date_format = date_format or "%Y-%m-%d %H-%M-%S"
	return os.date(date_format, seconds)
end

function PropertyExpander:expand(format_string)
	local comparisons = {
		{
			-- Less than or equal
			"^(..-)<=(.+)$",
			function(property_value, other_value)
				if type(property_value) ~= "number" then
					return nil
				end
				return property_value <= tonumber(other_value)
			end,
		},
		{
			-- More than or equal
			"^(..-)>=(.+)$",
			function(property_value, other_value)
				if type(property_value) ~= "number" then
					return nil
				end
				return property_value >= tonumber(other_value)
			end,
		},
		{
			-- Less than
			"^(..-)<(.+)$",
			function(property_value, other_value)
				if type(property_value) ~= "number" then
					return nil
				end
				return property_value < tonumber(other_value)
			end,
		},
		{
			-- More than
			"^(..-)>(.+)$",
			function(property_value, other_value)
				if type(property_value) ~= "number" then
					return nil
				end
				return property_value > tonumber(other_value)
			end,
		},
		{
			-- Equal
			"^(..-)==(.+)$",
			function(property_value, other_value)
				if type(property_value) == "number" then
					other_value = tonumber(other_value)
				elseif type(property_value) ~= "string" then
					-- Ignore booleans and others
					return nil
				end
				return property_value == other_value
			end,
		},
		{
			-- Starts with
			"^(..-)^=(.+)$",
			function(property_value, other_value)
				if type(property_value) ~= "string" then
					return nil
				end
				return property_value:sub(1, other_value:len()) == other_value
			end,
		},
		{
			-- Ends with
			"^(..-)$=(.+)$",
			function(property_value, other_value)
				if type(property_value) ~= "string" then
					return nil
				end
				return other_value == "" or property_value:sub(-other_value:len()) == other_value
			end,
		},
		{
			-- Contains
			"^(..-)~=(.+)$",
			function(property_value, other_value)
				if type(property_value) ~= "string" then
					return nil
				end
				return property_value:find(other_value, nil, true) ~= nil
			end,
		},
	}

	local substitutor = function(match)
		local command, inner = match:sub(3, -2):match("^([%?!~^%%#&]?)(.+)$")
		local colon_index = inner:find(":")

		local property_name = inner
		local secondary = ""
		local has_colon = colon_index and true or false

		if colon_index then
			property_name = inner:sub(1, colon_index - 1)
			secondary = inner:sub(colon_index + 1, -1)
		end

		local used_comparison = nil
		local comparison_value = nil
		for i, comparison in ipairs(comparisons) do
			local name, other_value = property_name:match(comparison[1])
			if name then
				property_name = name
				comparison_value = other_value
				used_comparison = comparison[2]
				break
			end
		end

		local raw_property_value = self.property_source:get_raw_property(property_name, self.sentinel)
		local property_exists = raw_property_value ~= self.sentinel

		if command == "" then
			if used_comparison then
				if used_comparison(raw_property_value, comparison_value) then
					return self:expand(secondary)
				else
					return ""
				end
			end

			-- Return the property value if it's not nil, else the (expanded) secondary
			return property_exists and self.property_source:get_property(property_name) or self:expand(secondary)
		elseif command == "?" then
			-- Return (expanded) secondary if property is truthy (sentinel is falsey)
			if not isempty(raw_property_value) then
				return self:expand(secondary)
			else
				return ""
			end
		elseif command == "!" then
			if used_comparison then
				if not used_comparison(raw_property_value, comparison_value) then
					return self:expand(secondary)
				else
					return ""
				end
			end

			-- Return (expanded) secondary if property is falsey
			if isempty(raw_property_value) then
				return self:expand(secondary)
			else
				return ""
			end
		elseif command == "^" then
			-- Return (expanded) secondary if property does not exist
			return not property_exists and self:expand(secondary) or ""
		elseif command == "%" then
			-- Return the value formatted using the secondary string
			return secondary:format(raw_property_value)
		elseif command == "#" then
			-- Format a number to HMS
			return self:_format_time(raw_property_value, has_colon and secondary or nil)
		elseif command == "&" then
			-- Format a date
			return self:_format_date(nil, has_colon and secondary or nil)
		elseif command == "@" then
			-- Format the value for OSD - mostly useful for latching onto mpv's properties
			return property_exists and self.property_source:get_property_osd(property_name) or self:expand(secondary)
		end
	end

	-- Lua patterns are generally a pain, but %b is comfy!
	local expanded = format_string:gsub("%$%b{}", substitutor)
	return expanded
end

local MPVPropertySource = {}
MPVPropertySource.__index = MPVPropertySource

setmetatable(MPVPropertySource, {
	__call = function(cls, ...)
		return cls.new(...)
	end,
})

function MPVPropertySource.new(values)
	local self = setmetatable({}, MPVPropertySource)
	self.values = values

	return self
end

function MPVPropertySource:get_raw_property(name, default)
	if name:find("mpv/") ~= nil then
		return mp.get_property_native(name:sub(5), default)
	end
	local v = self.values[name]
	if v ~= nil then
		return v
	else
		return default
	end
end

function MPVPropertySource:get_property(name, default)
	if name:find("mpv/") ~= nil then
		return mp.get_property(name:sub(5), default)
	end
	local v = self.values[name]
	if v ~= nil then
		return tostring(v)
	else
		return default
	end
end

function MPVPropertySource:get_property_osd(name, default)
	if name:find("mpv/") ~= nil then
		return mp.get_property_osd(name:sub(5), default)
	end
	local v = self.values[name]
	if v ~= nil then
		return tostring(v)
	else
		return default
	end
end
function script_crop_toggle()
	if asscropper.active then
		asscropper:stop_crop(true)
	else
		local on_crop = function(crop)
			mp.set_osd_ass(0, 0, "")
			screenshot(crop)
		end
		local on_cancel = function()
			mp.osd_message("Crop canceled")
			mp.set_osd_ass(0, 0, "")
		end

		local crop_options = {
			guide_type = ({ none = 0, grid = 1, center = 2 })[option_values.guide_type],
			draw_mouse = option_values.draw_mouse,
			color_invert = option_values.color_invert,
			auto_invert = option_values.auto_invert,
		}
		asscropper:start_crop(crop_options, on_crop, on_cancel)
		if not asscropper.active then
			mp.osd_message("No video to crop!", 2)
		end
	end
end

local next_tick_time = nil
function on_tick_listener()
	local now = mp.get_time()
	if next_tick_time == nil or now >= next_tick_time then
		if asscropper.active and display_state:recalculate_bounds() then
			mp.set_osd_ass(display_state.screen.width, display_state.screen.height, asscropper:get_render_ass())
		end
		next_tick_time = now + (1 / 60)
	end
end

local function resolve_path(path)
	-- Expand tilde (~) to home directory
	local home = os.getenv("HOME")
	if home and path:sub(1, 2) == "~/" then
		path = home .. path:sub(2)
	end
	-- Convert relative paths to absolute paths
	return mp.command_native({ "expand-path", path })
end

function expand_output_path(cropbox)
	local filename = mp.get_property_native("filename")
	local playback_time = mp.get_property_native("playback-time")
	local duration = mp.get_property_native("duration")

	local filename_without_ext, extension = filename:match("^(.+)%.(.-)$")

	local properties = {
		path = mp.get_property_native("path"), -- Original path

		filename = filename_without_ext or filename, -- Filename without extension (or filename if no dots)
		file_ext = extension or "", -- Original extension without leading dot (or empty string)

		pos = playback_time,

		full = false,
		is_image = (duration == 0 and playback_time == 0),

		crop_w = cropbox.w,
		crop_h = cropbox.h,
		crop_x = cropbox.x,
		crop_y = cropbox.y,
		crop_x2 = cropbox.x2,
		crop_y2 = cropbox.y2,

		unique = 0,

		ext = option_values.output_extension,
	}

	local propex = PropertyExpander(MPVPropertySource(properties))

	local test_path = resolve_path(propex:expand(option_values.output_template))
	-- If the paths do not change when incrementing the unique, it's not used.
	-- Return early and avoid the endless loop
	properties.unique = 1
	if resolve_path(propex:expand(option_values.output_template)) == test_path then
		properties.full = true
		local temporary_screenshot_path = resolve_path(propex:expand(option_values.output_template))
		return test_path, temporary_screenshot_path
	else
		-- Figure out a unique filename
		while true do
			test_path = resolve_path(propex:expand(option_values.output_template))

			-- Check if filename is free
			if not path_exists(test_path) then
				properties.full = true
				local temporary_screenshot_path = resolve_path(propex:expand(option_values.output_template))
				return test_path, temporary_screenshot_path
			else
				-- Try the next one
				properties.unique = properties.unique + 1
			end
		end
	end
end

function screenshot(crop)
	local size = round_dec(crop.w) .. "x" .. round_dec(crop.h)

	-- Bail on bad crop sizes
	if not (crop.w > 0 and crop.h > 0) then
		mp.osd_message("Bad crop (" .. size .. ")!")
		return
	end

	local output_path, temporary_screenshot_path = expand_output_path(crop)

	-- Optionally create directories
	if option_values.create_directories then
		local paths = {}
		paths[1] = path_utils.dirname(output_path)
		paths[2] = path_utils.dirname(temporary_screenshot_path)

		-- Check if we can read the paths
		for i, path in ipairs(paths) do
			local l, err = utils.readdir(path)
			if err then
				create_directories(path)
			end
		end
	end

	local playback_time = mp.get_property_native("playback-time")
	local duration = mp.get_property_native("duration")

	local input_path = nil

	if option_values.skip_screenshot_for_images and duration == 0 and playback_time == 0 then
		-- Seems to be an image (or at least static file)
		input_path = mp.get_property_native("path")
		temporary_screenshot_path = nil
	else
		-- Not an image, take a temporary screenshot

		-- In case the full-size output path is identical to the crop path,
		-- crudely make it different
		if temporary_screenshot_path == output_path then
			temporary_screenshot_path = temporary_screenshot_path .. "_full.png"
		end

		-- Temporarily lower the PNG compression
		local previous_png_compression = mp.get_property_native("screenshot-png-compression")
		mp.set_property_native("screenshot-png-compression", 0)
		-- Take the screenshot
		mp.commandv("raw", "no-osd", "screenshot-to-file", temporary_screenshot_path)
		-- Return the previous value
		mp.set_property_native("screenshot-png-compression", previous_png_compression)

		if not path_exists(temporary_screenshot_path) then
			msg.error("Failed to take screenshot: " .. temporary_screenshot_path)
			mp.osd_message("Unable to save screenshot")
			return
		end

		input_path = temporary_screenshot_path
	end

	local crop_string = string.format("%d:%d:%d:%d", crop.w, crop.h, crop.x, crop.y)
	local cmd = {
		args = {
			"mpv",
			input_path,
			"--no-config",
			"--vf=crop=" .. crop_string,
			"--frames=1",
			"--ovc=" .. option_values.output_format,
			"-o",
			output_path,
		},
	}

	msg.info("Cropping: ", crop_string, output_path)
	local ret = utils.subprocess(cmd)

	if not option_values.keep_original and temporary_screenshot_path then
		os.remove(temporary_screenshot_path)
	end

	if ret.error or ret.status ~= 0 then
		mp.osd_message("Screenshot failed, see console for details")
		msg.error("Crop failed! mpv exit code: " .. tostring(ret.status))
		msg.error("mpv stdout:")
		msg.error(ret.stdout)
	else
		msg.info("Crop finished!")
		mp.osd_message("Took screenshot (" .. size .. ")")
	end
end

----------------------
-- Instances, binds --
----------------------

-- Sanity-check output_template
if option_values.warn_about_template and not option_values.output_template:find("%${ext}") then
	msg.warn("Output template missing ${ext}! If this is desired, set warn_about_template=yes in config!")
end

-- Short list of extensions for encoders
local ENCODER_EXTENSION_MAP = {
	png = "png",
	mjpeg = "jpg",
	targa = "tga",
	tiff = "tiff",
	gif = "gif", -- please don't
	bmp = "bmp",
	jpegls = "jpg",
	ljpeg = "jpg",
	jpeg2000 = "jp2",
}
-- Pick an extension if one was not provided
if option_values.output_extension == "" then
	local extension = ENCODER_EXTENSION_MAP[option_values.output_format]
	if not extension then
		msg.error(
			"Unrecognized output format '" .. option_values.output_format .. "', unable to pick an extension! Bailing!"
		)
		mp.osd_message("mpv_crop_script was unable to choose an extension, check your config", 3)
	end
	option_values.output_extension = extension
end

display_state = DisplayState()
asscropper = ASSCropper(display_state)
asscropper.overlay_transparency = option_values.overlay_transparency
asscropper.overlay_lightness = option_values.overlay_lightness

asscropper.tick_callback = on_tick_listener
mp.register_event("tick", on_tick_listener)

local used_keybind = SCRIPT_KEYBIND
-- Disable the default keybind if asked to
if option_values.disable_keybind then
	used_keybind = nil
end
mp.add_key_binding(used_keybind, SCRIPT_HANDLER, script_crop_toggle)