568 lines
15 KiB
Lua
568 lines
15 KiB
Lua
--[[
|
|
This file is part of mfpbar.
|
|
|
|
mfpbar is free software: you can redistribute it and/or modify it
|
|
under the terms of the GNU Affero General Public License as published by the
|
|
Free Software Foundation, either version 3 of the License, or (at your
|
|
option) any later version.
|
|
|
|
mfpbar 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 Affero General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with mfpbar. If not, see <https://www.gnu.org/licenses/>.
|
|
]]
|
|
|
|
local msg = require('mp.msg')
|
|
local utils = require('mp.utils')
|
|
local mpopt = require('mp.options')
|
|
|
|
-- poor man's enum
|
|
|
|
local pbar_uninit = 0
|
|
local pbar_hidden = 1
|
|
local pbar_minimized = 2
|
|
local pbar_active = 3
|
|
|
|
-- globals
|
|
|
|
local state = {
|
|
osd = nil,
|
|
dpy_w = 0,
|
|
dpy_h = 0,
|
|
pbar = pbar_uninit,
|
|
mouse = nil,
|
|
mouse_prev = nil,
|
|
cached_ranges = nil,
|
|
duration = nil,
|
|
chapters = nil,
|
|
timeout = nil,
|
|
time_observed = false,
|
|
press_bounded = false,
|
|
fullscreen = false,
|
|
thumbfast = {
|
|
width = 0,
|
|
height = 0,
|
|
disabled = true,
|
|
available = false
|
|
},
|
|
}
|
|
|
|
local opt = {
|
|
pbar_height = 2,
|
|
pbar_minimized_height = 0.5,
|
|
pbar_color = "CCCCCC",
|
|
pbar_bg_alpha = "3F",
|
|
pbar_fullscreen_hide = true,
|
|
cachebar_height = 0.24,
|
|
cachebar_color = "1C6C89",
|
|
cachebar_uncached_color = "CC3A2A",
|
|
cachebar_uncached_alpha = "70",
|
|
-- TODO: allow selecting "duration" as well ?
|
|
timeline_rhs = "time-remaining",
|
|
hover_bar_color = "BDAE93",
|
|
font_size = 16,
|
|
font_pad = 4, -- TODO: rename this to hpad ?
|
|
-- TODO: add a configurable vpad as well ?
|
|
font_border_width = 2,
|
|
font_border_color = "000000",
|
|
proximity = 40,
|
|
preview_border_width = 2,
|
|
preview_border_color = "BDAE93",
|
|
chapter_marker_size = 3,
|
|
chapter_marker_color = "BDAE93",
|
|
chapter_marker_border_width = 1,
|
|
chapter_marker_border_color = "161616",
|
|
minimize_timeout = 3,
|
|
|
|
debug = false,
|
|
}
|
|
|
|
local zassert = function() end
|
|
|
|
-- function implementation
|
|
|
|
-- ASS uses BBGGRR format, which fucking sucks
|
|
local function rgb_to_ass(color)
|
|
if (not string.len(color) == 6) then
|
|
msg.error("Invalid color: " .. color)
|
|
return "FFFFFF"
|
|
end
|
|
local r = string.sub(color, 1, 2)
|
|
local g = string.sub(color, 3, 4)
|
|
local b = string.sub(color, 5, 6)
|
|
return string.upper(b .. g .. r)
|
|
end
|
|
|
|
local function grab_chapter_name_at(sec)
|
|
zassert(state.chapters)
|
|
local name = nil
|
|
local psec = -1
|
|
for _, c in ipairs(state.chapters) do
|
|
if (sec > c.time) then
|
|
name = c.title
|
|
end
|
|
zassert(psec <= c.time)
|
|
psec = c.time
|
|
end
|
|
return name
|
|
end
|
|
|
|
local function format_time(t)
|
|
local h = math.floor(t / (60 * 60))
|
|
t = t - (h * 60 * 60)
|
|
local m = math.floor(t / 60)
|
|
local s = t - (m * 60)
|
|
return string.format("%.2d:%.2d:%.2d", h, m, s)
|
|
end
|
|
|
|
local function round(n)
|
|
zassert(n >= 0)
|
|
return math.floor(n + 0.5)
|
|
end
|
|
|
|
local function clamp(n, min, max)
|
|
return math.min(math.max(n, min), max)
|
|
end
|
|
|
|
local function hover_to_sec(mx, dw, duration)
|
|
zassert(duration)
|
|
local n = duration * ((mx + 0.5) / dw)
|
|
return clamp(n, 0, duration)
|
|
end
|
|
|
|
local function render()
|
|
state.osd:update()
|
|
state.osd.data = nil
|
|
end
|
|
|
|
local function draw_append(text)
|
|
if (state.osd.data == nil) then
|
|
state.osd.data = text
|
|
else
|
|
state.osd.data = state.osd.data .. '\n' .. text
|
|
end
|
|
end
|
|
|
|
local function draw_rect_point(x0, y0, x1, y1, x2, y2, x3, y3, color, opt)
|
|
local s = '{\\pos(0, 0)}'
|
|
opt = opt or {}
|
|
s = s .. '{\\1c&' .. color .. '&}'
|
|
s = s .. '{\\1a&' .. (opt.alpha or "00") .. '&}'
|
|
s = s .. '{\\bord' .. (opt.bw or '0') .. '}'
|
|
s = s .. '{\\3c&' .. (opt.bcolor or "000000") .. '&}'
|
|
s = s .. string.format(
|
|
'{\\p1}m %d %d l %d %d %d %d %d %d{\\p0}',
|
|
x0, y0, x1, y1, x2, y2, x3, y3
|
|
)
|
|
draw_append(s)
|
|
end
|
|
|
|
local function draw_rect(x, y, w, h, color, opt)
|
|
draw_rect_point(
|
|
x, y,
|
|
x + w, y,
|
|
x + w, y + h,
|
|
x, y + h,
|
|
color, opt
|
|
)
|
|
end
|
|
|
|
local function draw_text(x, y, size, text, opt)
|
|
local s = string.format('{\\pos(%d, %d)}{\\fs%d}', x, y, size)
|
|
opt = opt or {}
|
|
s = s .. '{\\bord' .. (opt.bw or '0') .. '}'
|
|
s = s .. '{\\3c&' .. (opt.bcolor or "000000") .. '&}'
|
|
s = s .. text
|
|
draw_append(s)
|
|
end
|
|
|
|
-- TODO: make this less janky.
|
|
local function pbar_draw()
|
|
local dpy_w = state.dpy_w
|
|
local dpy_h = state.dpy_h
|
|
local ypos = 0
|
|
local play_pos = mp.get_property_native("percent-pos")
|
|
local duration = state.duration
|
|
local clist = state.chapters
|
|
|
|
zassert(state.pbar == pbar_minimized or state.pbar == pbar_active)
|
|
|
|
if (play_pos == nil or dpy_w == 0 or dpy_h == 0) then
|
|
return
|
|
end
|
|
|
|
-- L0: playback cursor
|
|
local pb_h = state.pbar == pbar_minimized and opt.pbar_minimized_height or opt.pbar_height
|
|
zassert(pb_h > 0)
|
|
pb_h = dpy_h * (pb_h / 100)
|
|
pb_h = math.max(round(pb_h), 4)
|
|
local pb_w = dpy_w * (play_pos/100.0)
|
|
local pb_y = dpy_h - (pb_h + ypos)
|
|
draw_rect(0, pb_y, pb_w, pb_h, opt.pbar_color)
|
|
draw_rect(pb_w, pb_y, dpy_w - pb_w, pb_h, "000000", { alpha = opt.pbar_bg_alpha })
|
|
ypos = ypos + pb_h
|
|
|
|
if (duration) then
|
|
-- L1: cache cusor
|
|
if (state.cached_ranges and opt.cachebar_height > 0) then
|
|
zassert(#state.cached_ranges > 0)
|
|
local ch = dpy_h * (opt.cachebar_height / 100)
|
|
ch = math.max(round(ch), 2)
|
|
draw_rect(
|
|
0, dpy_h - (ch + ypos), dpy_w, ch,
|
|
opt.cachebar_uncached_color,
|
|
{ alpha = opt.cachebar_uncached_alpha }
|
|
)
|
|
for _, range in ipairs(state.cached_ranges) do
|
|
local s = range['start']
|
|
local e = range['end']
|
|
local sp = dpy_w * (s / duration)
|
|
local ep = (dpy_w * (e / duration)) - sp
|
|
|
|
draw_rect(sp, dpy_h - (ch + ypos), ep, ch, opt.cachebar_color)
|
|
end
|
|
ypos = ypos + ch
|
|
end
|
|
|
|
-- L0-???: chapters
|
|
if (clist and opt.chapter_marker_size > 0) then
|
|
zassert(#clist > 0)
|
|
local bw = opt.chapter_marker_border_width
|
|
local tw = opt.chapter_marker_size
|
|
local miny = tw + bw + 1 -- +1 for pad
|
|
local y = dpy_h - math.max(pb_h / 2, miny)
|
|
for _, c in ipairs(clist) do
|
|
local x = dpy_w * (c.time / duration)
|
|
draw_rect_point(
|
|
x - tw, y,
|
|
x, y - tw,
|
|
x + tw, y,
|
|
x, y + tw,
|
|
opt.chapter_marker_color,
|
|
{ bw = bw, bcolor = opt.chapter_marker_border_color }
|
|
)
|
|
end
|
|
ypos = math.max(ypos, dpy_h - (y + tw + bw))
|
|
end
|
|
end
|
|
|
|
if (state.pbar == pbar_active) then
|
|
local fs = opt.font_size
|
|
local pad = opt.font_pad
|
|
local fopt = { bw = opt.font_border_width, bcolor = opt.font_border_color }
|
|
|
|
-- L2: timeline
|
|
-- LHS: current playback position
|
|
local time = mp.get_property_osd("time-pos", "00:00:00")
|
|
draw_text(pad, dpy_h - (ypos + fs), fs, time, fopt)
|
|
-- RHS: time/playback remaining
|
|
local rem = "-" .. mp.get_property_osd(opt.timeline_rhs, "99:99:99")
|
|
draw_text(dpy_w - pad, dpy_h - (ypos + fs), fs, "{\\an9}" .. rem, fopt)
|
|
ypos = ypos + fs + (fopt.bw * 2)
|
|
|
|
if (duration) then
|
|
zassert(state.mouse)
|
|
|
|
-- L0-2: hovered timeline
|
|
local hover_sec = hover_to_sec(state.mouse.x, dpy_w, duration)
|
|
local hover_text = format_time(hover_sec)
|
|
draw_rect(
|
|
math.max(state.mouse.x - 1, 0), dpy_h - ypos,
|
|
2, ypos, opt.hover_bar_color
|
|
)
|
|
local fw = fs * 2 -- guesstimate ¯\_(ツ)_/¯
|
|
local x = clamp(state.mouse.x, pad + fw, dpy_w - (pad + fw))
|
|
draw_text(
|
|
x, dpy_h - (ypos + fs), fs,
|
|
"{\\an8}" .. hover_text, fopt
|
|
)
|
|
ypos = ypos + fs + (fopt.bw * 2)
|
|
|
|
-- L3: chapter name
|
|
local cname = clist and grab_chapter_name_at(hover_sec) or nil
|
|
if cname then
|
|
zassert(cname)
|
|
local fw = string.len(cname) * fs * 0.28 -- guesstimate again
|
|
local x = clamp(state.mouse.x, pad + fw, dpy_w - (pad + fw))
|
|
draw_text(
|
|
x, dpy_h - (ypos + fs),
|
|
fs, "{\\an8}" .. cname, fopt
|
|
)
|
|
ypos = ypos + fs + (fopt.bw * 2)
|
|
end
|
|
|
|
-- L4: preview thumbnail
|
|
if not state.thumbfast.disabled then
|
|
local pw = opt.preview_border_width
|
|
local hpad = 4 + pw
|
|
local tw = state.thumbfast.width
|
|
local th = state.thumbfast.height
|
|
local y = dpy_h - (ypos + th + pw)
|
|
local x = state.mouse.x - (tw / 2)
|
|
x = clamp(x, hpad, dpy_w - (hpad + tw))
|
|
mp.commandv(
|
|
"script-message-to", "thumbfast", "thumb",
|
|
hover_sec, x, y
|
|
)
|
|
ypos = ypos + th + pw
|
|
|
|
-- L4: preview border
|
|
if pw > 0 then
|
|
local c = opt.preview_border_color
|
|
draw_rect(
|
|
x, y, tw, th, "161616",
|
|
{ alpha = "7F", bw = pw, bcolor = c }
|
|
)
|
|
ypos = ypos + pw
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
render()
|
|
end
|
|
|
|
local function pbar_pressed()
|
|
zassert(state.mouse.hover)
|
|
zassert(state.pbar == pbar_active)
|
|
if (state.duration) then
|
|
mp.set_property("time-pos", hover_to_sec(
|
|
state.mouse.x, state.dpy_w, state.duration
|
|
));
|
|
end
|
|
end
|
|
|
|
local function pbar_update(next_state)
|
|
local dpy_w = state.dpy_w
|
|
local dpy_h = state.dpy_h
|
|
|
|
if (dpy_w == 0 or dpy_h == 0 or
|
|
state.pbar == next_state or state.pbar == pbar_uninit)
|
|
then
|
|
return
|
|
end
|
|
|
|
zassert(dpy_w > 0)
|
|
zassert(dpy_h > 0)
|
|
|
|
local statestr = {
|
|
[pbar_uninit] = "uninit", [pbar_active] = "active",
|
|
[pbar_minimized] = "minimized", [pbar_hidden] = "hidden"
|
|
}
|
|
msg.debug('[UPDATE]: ', statestr[state.pbar], '=> ', statestr[next_state]);
|
|
|
|
-- TODO: reduce latency when pbar is active
|
|
if (next_state == pbar_active) then
|
|
state.pbar = pbar_active
|
|
pbar_draw()
|
|
if (not state.press_bounded) then
|
|
mp.add_forced_key_binding('mbtn_left', 'pbar_pressed', pbar_pressed)
|
|
state.press_bounded = true
|
|
end
|
|
if (not state.time_observed) then
|
|
mp.observe_property("time-pos", nil, pbar_draw)
|
|
state.time_observed = true
|
|
end
|
|
else
|
|
if (next_state == pbar_minimized) then
|
|
zassert(opt.pbar_minimized_height > 0)
|
|
state.pbar = pbar_minimized
|
|
pbar_draw()
|
|
if (not state.time_observed) then
|
|
mp.observe_property("time-pos", nil, pbar_draw)
|
|
state.time_observed = true
|
|
end
|
|
elseif (next_state == pbar_hidden) then
|
|
zassert(state.pbar ~= pbar_hidden)
|
|
state.pbar = pbar_hidden
|
|
state.osd.data = '' -- clear everything
|
|
render()
|
|
zassert(state.time_observed)
|
|
mp.unobserve_property(pbar_draw)
|
|
state.time_observed = false
|
|
else
|
|
zassert(false, "unreachable")
|
|
end
|
|
|
|
if (state.press_bounded) then
|
|
mp.remove_key_binding('pbar_pressed')
|
|
state.press_bounded = false
|
|
end
|
|
state.mouse = nil
|
|
if (state.thumbfast.available) then
|
|
mp.commandv("script-message-to", "thumbfast", "clear")
|
|
end
|
|
end
|
|
end
|
|
|
|
local function pbar_minimize_or_hide()
|
|
msg.debug("[MIN-HIDE]")
|
|
if (opt.pbar_minimized_height > 0 and not (opt.pbar_fullscreen_hide and state.fullscreen)) then
|
|
pbar_update(pbar_minimized)
|
|
else
|
|
pbar_update(pbar_hidden)
|
|
end
|
|
end
|
|
|
|
local function mouse_isactive(m)
|
|
return m.hover and math.abs(m.y - state.dpy_h) < opt.proximity
|
|
end
|
|
|
|
local function update_mouse_pos(kind, mouse)
|
|
zassert(kind == "mouse-pos")
|
|
state.mouse_prev = state.mouse or { hover = false }
|
|
state.mouse = mouse
|
|
msg.debug('[MOUSE] hover = ', mouse.hover, ' x = ', mouse.x, ' y = ', mouse.y)
|
|
|
|
local dpy_w = state.dpy_w
|
|
local dpy_h = state.dpy_h
|
|
|
|
if (dpy_w == 0 or dpy_h == 0) then
|
|
return
|
|
end
|
|
|
|
zassert(dpy_w > 0)
|
|
zassert(dpy_h > 0)
|
|
zassert(mouse)
|
|
|
|
-- TODO: ensure there's enough height to draw our stuff ?
|
|
if (mouse_isactive(state.mouse_prev) and mouse_isactive(mouse)) then
|
|
-- TODO: a better way to do this without killing/resuming a
|
|
-- timer on each mouse update?
|
|
state.timeout:kill()
|
|
state.timeout:resume()
|
|
pbar_update(pbar_active)
|
|
else
|
|
state.timeout:kill()
|
|
pbar_minimize_or_hide()
|
|
end
|
|
end
|
|
|
|
local function update_fullscreen(kind, fs)
|
|
zassert(kind == "fullscreen")
|
|
state.fullscreen = fs
|
|
msg.debug('[FULLSCREEN] fs = ', fs)
|
|
pbar_minimize_or_hide()
|
|
end
|
|
|
|
local function update_focus(kind, foc)
|
|
zassert(kind == "focused")
|
|
msg.debug('[FOCUS] focus = ', foc)
|
|
state.mouse_prev = { hover = false, x = 0, y = 0 }
|
|
end
|
|
|
|
local function set_dpy_size(kind, osd)
|
|
zassert(kind == "osd-dimensions")
|
|
state.dpy_w = osd.w
|
|
state.osd.res_x = osd.w
|
|
state.dpy_h = osd.h
|
|
state.osd.res_y = osd.h
|
|
msg.debug('[DPY] w = ', osd.w, ' h = ', osd.h)
|
|
|
|
-- HACK: ensure we don't obstruct the console (excluding the preview and hovered timeline)
|
|
-- the shared_script_property_* functions are documented as undocumented :)
|
|
-- and users are discouraged to use them, but whatever...
|
|
local b = (opt.font_size + (opt.font_border_width * 2) + 8) / state.dpy_h -- +8 padding
|
|
b = b + ((opt.pbar_minimized_height + opt.cachebar_height) / 100.0)
|
|
utils.shared_script_property_set(
|
|
'osc-margins',
|
|
string.format('%f,%f,%f,%f', 0, 0, 0, b)
|
|
)
|
|
end
|
|
|
|
local function set_cache_state(kind, c)
|
|
zassert(kind == "demuxer-cache-state")
|
|
if (c == nil) then
|
|
state.cached_ranges = nil
|
|
else
|
|
local r = c['seekable-ranges']
|
|
if #r > 0 then
|
|
state.cached_ranges = r
|
|
else
|
|
state.cached_ranges = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
local function set_duration(kind, d)
|
|
zassert(kind == "duration")
|
|
state.duration = d
|
|
end
|
|
|
|
local function set_chapter_list(kind, c)
|
|
zassert(kind == "chapter-list")
|
|
if (c and #c > 0) then
|
|
state.chapters = c
|
|
table.sort(state.chapters, function(a, b) return a.time < b.time end)
|
|
else
|
|
state.chapters = nil
|
|
end
|
|
end
|
|
|
|
local function set_thumbfast(json)
|
|
local data = utils.parse_json(json)
|
|
if (type(data) ~= "table" or not data.width or not data.height) then
|
|
msg.error("thumbfast-info: received json didn't produce a table with thumbnail information")
|
|
else
|
|
state.thumbfast = data
|
|
end
|
|
end
|
|
|
|
local function pbar_init(kind, thing)
|
|
zassert(kind == 'vo-configured')
|
|
msg.debug("[VO-CONFIGURED]", thing, state.pbar)
|
|
|
|
if thing then
|
|
zassert(state.pbar == pbar_uninit)
|
|
state.pbar = pbar_hidden
|
|
if (opt.pbar_minimized_height > 0) then
|
|
pbar_update(pbar_minimized)
|
|
end
|
|
mp.unobserve_property(pbar_init)
|
|
end
|
|
end
|
|
|
|
local function init()
|
|
mpopt.read_options(opt, "mfpbar")
|
|
for k,v in pairs(opt) do
|
|
if string.find(k, "_color$") then
|
|
opt[k] = rgb_to_ass(v)
|
|
end
|
|
end
|
|
|
|
if opt.debug then
|
|
msg.debug("[ASSERTIONS] enabled")
|
|
zassert = assert
|
|
else
|
|
zassert(false)
|
|
end
|
|
|
|
state.osd = mp.create_osd_overlay("ass-events")
|
|
mp.observe_property("osd-dimensions", "native", set_dpy_size)
|
|
mp.observe_property('demuxer-cache-state', 'native', set_cache_state)
|
|
mp.observe_property('duration', 'native', set_duration)
|
|
mp.observe_property('chapter-list', 'native', set_chapter_list)
|
|
mp.register_script_message("thumbfast-info", set_thumbfast)
|
|
mp.observe_property('fullscreen', 'native', update_fullscreen)
|
|
mp.observe_property('focused', 'native', update_focus)
|
|
|
|
-- NOTE: mouse-pos doesn't work mpv versions older than v33
|
|
mp.observe_property("mouse-pos", "native", update_mouse_pos)
|
|
|
|
if (opt.minimize_timeout > 0) then
|
|
state.timeout = mp.add_timeout(opt.minimize_timeout, pbar_minimize_or_hide)
|
|
state.timeout:kill() -- update_mouse_pos() will kill/resume this as needed
|
|
else
|
|
state.timeout = { kill = function() end, resume = function() end }
|
|
end
|
|
|
|
-- HACK: mpv doesn't open the window instantly by default.
|
|
-- so wait for 'vo-configured' as a hook for when the window opens.
|
|
mp.observe_property('vo-configured', 'native', pbar_init)
|
|
end
|
|
|
|
init()
|