summaryrefslogtreecommitdiff
path: root/mpv/scripts/quality-menu.lua
diff options
context:
space:
mode:
authorzachir <zachir@librem.one>2022-10-05 22:00:32 -0500
committerzachir <zachir@librem.one>2022-10-05 22:00:32 -0500
commitf39d735e2ba625a31a7dbf6fb8bdd62501379ad1 (patch)
treed17c96714c930e0b8bc75616cc9c81b961ed5aa0 /mpv/scripts/quality-menu.lua
Initial Commit
Diffstat (limited to 'mpv/scripts/quality-menu.lua')
-rw-r--r--mpv/scripts/quality-menu.lua806
1 files changed, 806 insertions, 0 deletions
diff --git a/mpv/scripts/quality-menu.lua b/mpv/scripts/quality-menu.lua
new file mode 100644
index 0000000..c5da0d3
--- /dev/null
+++ b/mpv/scripts/quality-menu.lua
@@ -0,0 +1,806 @@
+-- quality-menu.lua
+--
+-- Change the stream video and audio quality on the fly.
+--
+-- Usage:
+-- add bindings to input.conf:
+-- Ctrl+f script-message-to quality_menu video_formats_toggle
+-- Alt+f script-message-to quality_menu audio_formats_toggle
+--
+-- Displays a menu that lets you switch to different ytdl-format settings while
+-- you're in the middle of a video (just like you were using the web player).
+
+local mp = require 'mp'
+local utils = require 'mp.utils'
+local msg = require 'mp.msg'
+local assdraw = require 'mp.assdraw'
+local opt = require('mp.options')
+
+local opts = {
+ --key bindings
+ up_binding = "UP WHEEL_UP",
+ down_binding = "DOWN WHEEL_DOWN",
+ select_binding = "ENTER MBTN_LEFT",
+ close_menu_binding = "ESC MBTN_RIGHT Ctrl+f Alt+f",
+
+ --youtube-dl version(could be youtube-dl or yt-dlp, or something else)
+ ytdl_ver = "yt-dlp",
+
+ --formatting / cursors
+ selected_and_active = "▶ - ",
+ selected_and_inactive = "● - ",
+ unselected_and_active = "▷ - ",
+ unselected_and_inactive = "○ - ",
+
+ --font size scales by window, if false requires larger font and padding sizes
+ scale_playlist_by_window=true,
+
+ --playlist ass style overrides inside curly brackets, \keyvalue is one field, extra \ for escape in lua
+ --example {\\fnUbuntu\\fs10\\b0\\bord1} equals: font=Ubuntu, size=10, bold=no, border=1
+ --read http://docs.aegisub.org/3.2/ASS_Tags/ for reference of tags
+ --undeclared tags will use default osd settings
+ --these styles will be used for the whole playlist. More specific styling will need to be hacked in
+ --
+ --(a monospaced font is recommended but not required)
+ style_ass_tags = "{\\fnmonospace\\fs10\\bord1}",
+
+ --paddings for top left corner
+ text_padding_x = 5,
+ text_padding_y = 5,
+
+ --how many seconds until the quality menu times out
+ --setting this to 0 deactivates the timeout
+ menu_timeout = 6,
+
+ --use youtube-dl to fetch a list of available formats (overrides quality_strings)
+ fetch_formats = true,
+
+ --default menu entries
+ quality_strings=[[
+ [
+ {"4320p" : "bestvideo[height<=?4320p]+bestaudio/best"},
+ {"2160p" : "bestvideo[height<=?2160]+bestaudio/best"},
+ {"1440p" : "bestvideo[height<=?1440]+bestaudio/best"},
+ {"1080p" : "bestvideo[height<=?1080]+bestaudio/best"},
+ {"720p" : "bestvideo[height<=?720]+bestaudio/best"},
+ {"480p" : "bestvideo[height<=?480]+bestaudio/best"},
+ {"360p" : "bestvideo[height<=?360]+bestaudio/best"},
+ {"240p" : "bestvideo[height<=?240]+bestaudio/best"},
+ {"144p" : "bestvideo[height<=?144]+bestaudio/best"}
+ ]
+ ]],
+
+ --reset ytdl-format to the original format string when changing files (e.g. going to the next playlist entry)
+ --if file was opened previously, reset to previously selected format
+ reset_format = true,
+
+ --automatically fetch available formats when opening an url
+ fetch_on_start = true,
+
+ --show the video format menu after opening an url
+ start_with_menu = false,
+
+ --include unknown formats in the list
+ --Unfortunately choosing which formats are video or audio is not always perfect.
+ --Set to true to make sure you don't miss any formats, but then the list
+ --might also include formats that aren't actually video or audio.
+ --Formats that are known to not be video or audio are still filtered out.
+ include_unknown = false,
+
+ --hide columns that are identical for all formats
+ hide_identical_columns = true,
+
+ --which columns are shown in which order
+ --comma separated list, prefix column with "-" to align left
+ --
+ --columns that might be useful are:
+ --resolution, width, height, fps, dynamic_range, tbr, vbr, abr, asr,
+ --filesize, filesize_approx, vcodec, acodec, ext, video_ext, audio_ext,
+ --language, format, format_note, quality
+ --
+ --columns that are derived from the above, but with special treatment:
+ --frame_rate, bitrate_total, bitrate_video, bitrate_audio,
+ --codec_video, codec_audio, audio_sample_rate
+ --
+ --If those still aren't enough or you're just curious, run:
+ --yt-dlp -j <url>
+ --This outputs unformatted JSON.
+ --Format it and look under "formats" to see what's available.
+ --
+ --Not all videos have all columns available.
+ --Be careful, misspelled columns simply won't be displayed, there is no error.
+ columns_video = '-resolution,frame_rate,dynamic_range,language,bitrate_total,size,-codec_video,-codec_audio',
+ columns_audio = 'audio_sample_rate,bitrate_total,size,language,-codec_audio',
+
+ --columns used for sorting, see "columns_video" for available columns
+ --comma separated list, prefix column with "-" to reverse sorting order
+ --Leaving this empty keeps the order from yt-dlp/youtube-dl.
+ --Be careful, misspelled columns won't result in an error,
+ --but they might influence the result.
+ sort_video = 'height,fps,tbr,size,format_id',
+ sort_audio = 'asr,tbr,size,format_id',
+}
+opt.read_options(opts, "quality-menu")
+opts.quality_strings = utils.parse_json(opts.quality_strings)
+
+-- special thanks to reload.lua (https://github.com/4e6/mpv-reload/)
+local function reload_resume()
+ local playlist_pos = mp.get_property_number("playlist-pos")
+ local reload_duration = mp.get_property_native("duration")
+ local time_pos = mp.get_property("time-pos")
+
+ mp.set_property_number("playlist-pos", playlist_pos)
+
+ -- Tries to determine live stream vs. pre-recorded VOD. VOD has non-zero
+ -- duration property. When reloading VOD, to keep the current time position
+ -- we should provide offset from the start. Stream doesn't have fixed start.
+ -- Decent choice would be to reload stream from it's current 'live' position.
+ -- That's the reason we don't pass the offset when reloading streams.
+ if reload_duration and reload_duration > 0 then
+ local function seeker()
+ mp.commandv("seek", time_pos, "absolute")
+ mp.unregister_event(seeker)
+ end
+ mp.register_event("file-loaded", seeker)
+ end
+end
+
+local ytdl = {
+ path = opts.ytdl_ver,
+ searched = false,
+ blacklisted = {}
+}
+
+local function process_json(json)
+ local function is_video(format)
+ -- "none" means it is not a video
+ -- nil means it is unknown
+ return (opts.include_unknown or format.vcodec) and format.vcodec ~= "none"
+ end
+
+ local function is_audio(format)
+ return (opts.include_unknown or format.acodec) and format.acodec ~= "none"
+ end
+
+ local vfmt = nil
+ local afmt = nil
+ local requested_formats = json["requested_formats"] or json["requested_downloads"]
+ for _, format in ipairs(requested_formats) do
+ if is_video(format) then
+ vfmt = format["format_id"]
+ elseif is_audio(format) then
+ afmt = format["format_id"]
+ end
+ end
+
+ local video_formats = {}
+ local audio_formats = {}
+ local all_formats = {}
+ for i = #json.formats, 1, -1 do
+ local format = json.formats[i]
+ if is_video(format) then
+ video_formats[#video_formats+1] = format
+ all_formats[#all_formats+1] = format
+ elseif is_audio(format) then
+ audio_formats[#audio_formats+1] = format
+ all_formats[#all_formats+1] = format
+ end
+ end
+
+ local function populate_special_fields(format)
+ format.size = format.filesize or format.filesize_approx
+ format.frame_rate = format.fps
+ format.bitrate_total = format.tbr
+ format.bitrate_video = format.vbr
+ format.bitrate_audio = format.abr
+ format.codec_video = format.vcodec
+ format.codec_audio = format.acodec
+ format.audio_sample_rate = format.asr
+ end
+
+ for _,format in ipairs(all_formats) do
+ populate_special_fields(format)
+ end
+
+ local function strip_minus(list)
+ local stripped_list = {}
+ local had_minus = {}
+ for i, val in ipairs(list) do
+ if string.sub(val, 1, 1) == "-" then
+ val = string.sub(val, 2)
+ had_minus[val] = true
+ end
+ stripped_list[i] = val
+ end
+ return stripped_list, had_minus
+ end
+
+ local function string_split (inputstr, sep)
+ if sep == nil then
+ sep = "%s"
+ end
+ local t={}
+ for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
+ table.insert(t, str)
+ end
+ return t
+ end
+
+ local sort_video, reverse_video = strip_minus(string_split(opts.sort_video, ','))
+ local sort_audio, reverse_audio = strip_minus(string_split(opts.sort_audio, ','))
+
+ local function comp(properties, reverse)
+ return function (a, b)
+ for _,prop in ipairs(properties) do
+ local a_val = a[prop]
+ local b_val = b[prop]
+ if a_val and b_val and type(a_val) ~= 'table' and a_val ~= b_val then
+ if reverse[prop] then
+ return a_val < b_val
+ else
+ return a_val > b_val
+ end
+ end
+ end
+ return false
+ end
+ end
+
+ if #sort_video > 0 then
+ table.sort(video_formats, comp(sort_video, reverse_video))
+ end
+ if #sort_audio > 0 then
+ table.sort(audio_formats, comp(sort_audio, reverse_audio))
+ end
+
+ local function scale_filesize(size)
+ if size == nil then
+ return ""
+ end
+ size = tonumber(size)
+
+ local counter = 0
+ while size > 1024 do
+ size = size / 1024
+ counter = counter+1
+ end
+
+ if counter >= 3 then return string.format("%.1fGiB", size)
+ elseif counter >= 2 then return string.format("%.1fMiB", size)
+ elseif counter >= 1 then return string.format("%.1fKiB", size)
+ else return string.format("%.1fB ", size)
+ end
+ end
+
+ local function scale_bitrate(br)
+ if br == nil then
+ return ""
+ end
+ br = tonumber(br)
+
+ local counter = 0
+ while br > 1000 do
+ br = br / 1000
+ counter = counter+1
+ end
+
+ if counter >= 2 then return string.format("%.1fGbps", br)
+ elseif counter >= 1 then return string.format("%.1fMbps", br)
+ else return string.format("%.1fKbps", br)
+ end
+ end
+
+ local function format_special_fields(format)
+ local size_prefix = not format.filesize and format.filesize_approx and "~" or ""
+ format.size = (size_prefix) .. scale_filesize(format.size)
+ format.frame_rate = format.fps and format.fps.."fps" or ""
+ format.bitrate_total = scale_bitrate(format.tbr)
+ format.bitrate_video = scale_bitrate(format.vbr)
+ format.bitrate_audio = scale_bitrate(format.abr)
+ format.codec_video = format.vcodec == nil and "unknown" or format.vcodec == "none" and "" or format.vcodec
+ format.codec_audio = format.acodec == nil and "unknown" or format.acodec == "none" and "" or format.acodec
+ format.audio_sample_rate = format.asr and tostring(format.asr) .. "Hz" or ""
+ end
+
+ for _,format in ipairs(all_formats) do
+ format_special_fields(format)
+ end
+
+ local function format_table(formats, columns)
+ local function calc_shown_columns()
+ local display_col = {}
+ local column_widths = {}
+ local column_values = {}
+ local columns, column_align_left = strip_minus(columns)
+
+ for _,format in pairs(formats) do
+ for col, prop in ipairs(columns) do
+ local label = tostring(format[prop] or "")
+ format[prop] = label
+
+ if not column_widths[col] or column_widths[col] < label:len() then
+ column_widths[col] = label:len()
+ end
+
+ column_values[col] = column_values[col] or label
+ display_col[col] = display_col[col] or (column_values[col] ~= label)
+ end
+ end
+
+ local show_columns={}
+ for i, width in ipairs(column_widths) do
+ if width > 0 and not opts.hide_identical_columns or display_col[i] then
+ local prop = columns[i]
+ show_columns[#show_columns+1] = {
+ prop=prop,
+ width=width,
+ align_left=column_align_left[prop]
+ }
+ end
+ end
+ return show_columns
+ end
+
+ local show_columns = calc_shown_columns()
+
+ local spacing = 2
+ local res = {}
+ for _,f in ipairs(formats) do
+ local row = ''
+ for i,column in ipairs(show_columns) do
+ -- lua errors out with width > 99 ("invalid conversion specification")
+ local width = math.min(column.width * (column.align_left and -1 or 1), 99)
+ row = row .. (i > 1 and string.format('%' .. spacing .. 's', '') or '')
+ .. string.format('%' .. width .. 's', f[column.prop] or "")
+ end
+ res[#res+1] = {label=row, format=f.format_id}
+ end
+ return res
+ end
+
+ local columns_video = string_split(opts.columns_video, ',')
+ local columns_audio = string_split(opts.columns_audio, ',')
+ local vres = format_table(video_formats, columns_video)
+ local ares = format_table(audio_formats, columns_audio)
+ return vres, ares , vfmt, afmt
+end
+
+local function get_url()
+ local path = mp.get_property("path")
+ path = string.gsub(path, "ytdl://", "") -- Strip possible ytdl:// prefix.
+
+ local function is_url(s)
+ -- adapted the regex from https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url
+ return nil ~= string.match(path, "^[%w]-://[-a-zA-Z0-9@:%._\\+~#=]+%.[a-zA-Z0-9()][a-zA-Z0-9()]?[a-zA-Z0-9()]?[a-zA-Z0-9()]?[a-zA-Z0-9()]?[a-zA-Z0-9()]?[-a-zA-Z0-9()@:%_\\+.~#?&/=]*")
+ end
+
+ return is_url(path) and path or nil
+end
+
+local uosc = false
+local url_data={}
+local function process_json_string(url, json)
+ local json, err = utils.parse_json(json)
+
+ if (json == nil) then
+ mp.osd_message("fetching formats failed...", 2)
+ msg.error("failed to parse JSON data: " .. err)
+ return
+ end
+
+ if json.formats == nil then
+ return
+ end
+
+ local vres, ares , vfmt, afmt = process_json(json)
+ url_data[url] = {voptions=vres, aoptions=ares, vfmt=vfmt, afmt=afmt}
+ if uosc and get_url() == url then
+ mp.commandv('script-message-to', 'uosc', 'set', 'vformats', #vres)
+ mp.commandv('script-message-to', 'uosc', 'set', 'aformats', #ares)
+ end
+ return vres, ares , vfmt, afmt
+end
+
+local function download_formats(url)
+
+ mp.osd_message("fetching available formats with youtube-dl...", 60)
+
+ if not (ytdl.searched) then
+ local ytdl_mcd = mp.find_config_file(opts.ytdl_ver)
+ if not (ytdl_mcd == nil) then
+ msg.verbose("found youtube-dl at: " .. ytdl_mcd)
+ ytdl.path = ytdl_mcd
+ end
+ ytdl.searched = true
+ end
+
+ local function exec(args)
+ local res, err = mp.command_native({name = "subprocess", args = args, capture_stdout = true, capture_stderr = true})
+ return res.status, res.stdout, res.stderr
+ end
+
+ local ytdl_format = mp.get_property("ytdl-format")
+ local command = nil
+ if (ytdl_format == nil or ytdl_format == "") then
+ command = {ytdl.path, "--no-warnings", "--no-playlist", "-J", url}
+ else
+ command = {ytdl.path, "--no-warnings", "--no-playlist", "-J", "-f", ytdl_format, url}
+ end
+
+ msg.verbose("calling youtube-dl with command: " .. table.concat(command, " "))
+
+ local es, stdout, stderr = exec(command)
+
+ if (es < 0) or (stdout == nil) or (stdout == "") then
+ mp.osd_message("fetching formats failed...", 2)
+ msg.error("failed to get format list: " .. es)
+ msg.error("stderr: " .. stderr)
+ return
+ end
+
+ msg.verbose("youtube-dl succeeded!")
+ mp.osd_message("", 0)
+
+ local vres, ares , vfmt, afmt = process_json_string(url, stdout)
+ return vres, ares , vfmt, afmt
+end
+
+local function send_formats_to(type, url, script_name, options, format_id)
+ mp.commandv('script-message-to', script_name, type .. '_formats', url, utils.format_json(options or {}), format_id or '')
+end
+
+local queue_callback_video = {}
+local queue_callback_audio = {}
+local function get_formats()
+
+ local url = get_url()
+ if url == nil then
+ return
+ end
+
+ if url_data[url] then
+ local data = url_data[url]
+ return data.voptions, data.aoptions, data.vfmt, data.afmt, url
+ end
+
+ if opts.fetch_formats == false then
+ local vres = {}
+ for i,v in ipairs(opts.quality_strings) do
+ for k,v2 in pairs(v) do
+ vres[i] = {label = k, format=v2}
+ end
+ end
+ url_data[url] = {voptions=vres, aoptions={}, vfmt=nil, afmt=nil}
+ return vres, {}, nil, nil, url
+ end
+
+ local vres, ares , vfmt, afmt = download_formats(url)
+
+ for _, script_name in ipairs(queue_callback_video[url] or {}) do
+ send_formats_to('video', url, script_name, vres, vfmt)
+ end
+ for _, script_name in ipairs(queue_callback_audio[url] or {}) do
+ send_formats_to('audio', url, script_name, ares, afmt)
+ end
+
+ queue_callback_video[url] = nil
+ queue_callback_audio[url] = nil
+ return vres, ares , vfmt, afmt, url
+end
+
+local function format_string(vfmt, afmt)
+ if vfmt and afmt then
+ return vfmt.."+"..afmt
+ elseif vfmt then
+ return vfmt
+ elseif afmt then
+ return afmt
+ else
+ return ""
+ end
+end
+
+local function set_format(url, vfmt, afmt)
+ if (url_data[url].vfmt ~= vfmt or url_data[url].afmt ~= afmt) then
+ url_data[url].afmt = afmt
+ url_data[url].vfmt = vfmt
+ if url == mp.get_property("path") then
+ mp.set_property("ytdl-format", format_string(vfmt, afmt))
+ reload_resume()
+ end
+ end
+end
+
+local destroyer = nil
+local function show_menu(isvideo)
+
+ if destroyer then
+ destroyer()
+ end
+
+ local voptions, aoptions, vfmt, afmt, url = get_formats()
+
+ local options
+ local fmt
+ if isvideo then
+ options = voptions
+ fmt = vfmt
+ else
+ options = aoptions
+ fmt = afmt
+ end
+
+ if options == nil then
+ if uosc then
+ if isvideo then
+ mp.commandv('script-binding', 'uosc/video')
+ else
+ mp.commandv('script-binding', 'uosc/audio')
+ end
+ end
+
+ return
+ end
+
+ msg.verbose("current ytdl-format: "..format_string(vfmt, afmt))
+
+ local active = 0
+ local selected = 1
+ --set the cursor to the current format
+ if fmt then
+ for i,v in ipairs(options) do
+ if v.format == fmt then
+ active = i
+ selected = active
+ break
+ end
+ end
+ else
+ active = #options + 1
+ selected = active
+ end
+
+ if uosc then
+ local menu = {
+ title = isvideo and 'Video Formats' or 'Audio Formats',
+ items = {},
+ type = (isvideo and 'video' or 'audio') .. '_formats',
+ }
+ for i, option in ipairs(options) do
+ menu.items[i] = {
+ title = option.label,
+ active = i == active,
+ value = {
+ 'script-message-to',
+ 'quality_menu',
+ (isvideo and 'video' or 'audio') .. '-format-set',
+ url,
+ option.format}
+ }
+ end
+ menu.items[#menu.items + 1] = {
+ title = 'None',
+ value = {
+ 'script-message-to',
+ 'quality_menu',
+ (isvideo and 'video' or 'audio') .. '-format-set',
+ url}
+ }
+ local json = utils.format_json(menu)
+ mp.commandv('script-message-to', 'uosc', 'open-menu', json)
+ return
+ end
+
+ local function choose_prefix(i)
+ if i == selected and i == active then return opts.selected_and_active
+ elseif i == selected then return opts.selected_and_inactive end
+
+ if i ~= selected and i == active then return opts.unselected_and_active
+ elseif i ~= selected then return opts.unselected_and_inactive end
+ return "> " --shouldn't get here.
+ end
+
+ local function draw_menu()
+ local ass = assdraw.ass_new()
+
+ ass:pos(opts.text_padding_x, opts.text_padding_y)
+ ass:append(opts.style_ass_tags)
+
+ if #options > 0 then
+ for i,v in ipairs(options) do
+ ass:append(choose_prefix(i)..v.label.."\\N")
+ end
+ ass:append(choose_prefix(#options+1).."None")
+ else
+ ass:append("no formats found")
+ end
+
+ local w, h = mp.get_osd_size()
+ if opts.scale_playlist_by_window then w,h = 0, 0 end
+ mp.set_osd_ass(w, h, ass.text)
+ end
+
+ local num_options = #options + 1
+ local timeout = nil
+
+ local function selected_move(amt)
+ selected = selected + amt
+ if selected < 1 then selected = num_options
+ elseif selected > num_options then selected = 1 end
+ if timeout then
+ timeout:kill()
+ timeout:resume()
+ end
+ draw_menu()
+ end
+
+ local function bind_keys(keys, name, func, opts)
+ if not keys then
+ mp.add_forced_key_binding(keys, name, func, opts)
+ return
+ end
+ local i = 1
+ for key in keys:gmatch("[^%s]+") do
+ local prefix = i == 1 and '' or i
+ mp.add_forced_key_binding(key, name..prefix, func, opts)
+ i = i + 1
+ end
+ end
+
+ local function unbind_keys(keys, name)
+ if not keys then
+ mp.remove_key_binding(name)
+ return
+ end
+ local i = 1
+ for key in keys:gmatch("[^%s]+") do
+ local prefix = i == 1 and '' or i
+ mp.remove_key_binding(name..prefix)
+ i = i + 1
+ end
+ end
+
+ local function destroy()
+ if timeout then
+ timeout:kill()
+ end
+ mp.set_osd_ass(0,0,"")
+ unbind_keys(opts.up_binding, "move_up")
+ unbind_keys(opts.down_binding, "move_down")
+ unbind_keys(opts.select_binding, "select")
+ unbind_keys(opts.close_menu_binding, "close")
+ destroyer = nil
+ end
+
+ if opts.menu_timeout > 0 then
+ timeout = mp.add_periodic_timer(opts.menu_timeout, destroy)
+ end
+ destroyer = destroy
+
+ bind_keys(opts.up_binding, "move_up", function() selected_move(-1) end, {repeatable=true})
+ bind_keys(opts.down_binding, "move_down", function() selected_move(1) end, {repeatable=true})
+ if #options > 0 then
+ bind_keys(opts.select_binding, "select", function()
+ destroy()
+ if selected == active then return end
+
+ fmt = options[selected] and options[selected].format or nil
+ if isvideo then
+ vfmt = fmt
+ else
+ afmt = fmt
+ end
+ set_format(url, vfmt, afmt)
+ end)
+ end
+ bind_keys(opts.close_menu_binding, "close", destroy) --close menu using ESC
+ mp.osd_message("", 0)
+ draw_menu()
+end
+
+local ui_callback = {}
+
+local function video_formats_toggle()
+ if #ui_callback > 0 then
+ for _, name in ipairs(ui_callback) do
+ mp.commandv('script-message-to', name, 'video-formats-menu')
+ end
+ else
+ show_menu(true)
+ end
+end
+
+local function audio_formats_toggle()
+ if #ui_callback > 0 then
+ for _, name in ipairs(ui_callback) do
+ mp.commandv('script-message-to', name, 'audio-formats-menu')
+ end
+ else
+ show_menu(false)
+ end
+end
+
+-- keybind to launch menu
+mp.add_key_binding(nil, "video_formats_toggle", video_formats_toggle)
+mp.add_key_binding(nil, "audio_formats_toggle", audio_formats_toggle)
+mp.add_key_binding(nil, "reload", reload_resume)
+
+local original_format = mp.get_property("ytdl-format")
+local path = nil
+local function file_start()
+ local new_path = get_url()
+ if not new_path then return end
+
+ local data = url_data[new_path]
+
+ if uosc then
+ if data then
+ mp.commandv('script-message-to', 'uosc', 'set', 'vformats', #data.voptions)
+ mp.commandv('script-message-to', 'uosc', 'set', 'aformats', #data.aoptions)
+ else
+ mp.commandv('script-message-to', 'uosc', 'set', 'vformats', 0)
+ mp.commandv('script-message-to', 'uosc', 'set', 'aformats', 0)
+ end
+ end
+
+ if opts.reset_format and path and new_path ~= path then
+ if data then
+ msg.verbose("setting previously set format")
+ mp.set_property("ytdl-format", format_string(data.vfmt, data.afmt))
+ else
+ msg.verbose("setting original format")
+ mp.set_property("ytdl-format", original_format)
+ end
+ end
+ if opts.start_with_menu and new_path ~= path then
+ video_formats_toggle()
+ elseif opts.fetch_on_start and not data then
+ download_formats(new_path)
+ end
+ path = new_path
+end
+mp.register_event("start-file", file_start)
+
+mp.register_script_message('video-formats-get', function(url, script_name)
+ local data = url_data[url]
+ if data then
+ send_formats_to('video', url, script_name, data.voptions, data.vfmt)
+ else
+ local queue = queue_callback_video[url] or {}
+ queue[#queue + 1] = script_name
+ queue_callback_video[url] = queue
+ get_formats()
+ end
+end)
+
+mp.register_script_message('audio-formats-get', function(url, script_name)
+ local data = url_data[url]
+ if data then
+ send_formats_to('audio', url, script_name, data.aoptions, data.afmt)
+ else
+ local queue = queue_callback_audio[url] or {}
+ queue[#queue + 1] = script_name
+ queue_callback_audio[url] = queue
+ get_formats()
+ end
+end)
+
+mp.register_script_message('video-format-set', function(url, format_id)
+ set_format(url, format_id, url_data[url].afmt)
+end)
+
+mp.register_script_message('audio-format-set', function(url, format_id)
+ set_format(url, url_data[url].vfmt, format_id)
+end)
+
+mp.register_script_message('register-ui', function(script_name)
+ ui_callback[#ui_callback + 1] = script_name
+end)
+
+-- check if uosc is running
+mp.register_script_message('uosc-version', function(version)
+ version = tonumber((version:gsub('%.', '')))
+---@diagnostic disable-next-line: cast-local-type
+ uosc = version and version >= 400
+end)
+mp.commandv('script-message-to', 'uosc', 'get-version', mp.get_script_name()) \ No newline at end of file