sudacode/mpv
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: sudacode:1844d00653726f2d8f42f21ea39034c36bb4ad34
Branches Tags
sudacode:master
..
compare: sudacode:0acbc646b321b776459434ba6a5886a3204b3dc5
Branches Tags
sudacode:master

No commits in common. "1844d00653726f2d8f42f21ea39034c36bb4ad34" and "0acbc646b321b776459434ba6a5886a3204b3dc5" have entirely different histories.
1844d00653 ... 0acbc646b3

7 changed files with 4 additions and 1546 deletions
Show Stats Expand all files Collapse all files

2
mpv-youtube-queue

@ -1 +1 @@
Subproject commit 84a860f596eefc699a63a692b890471063beacc9
Subproject commit fa2014acd681c35a0027e8b13ae67ba27d24aca1

3
mpv.conf
View File

@ -163,8 +163,7 @@ osc=no
interpolation
tscale=oversample
# hwdec=auto-copy
hwdec=auto
hwdec=auto-copy
ytdl-raw-options=ignore-config=,sub-lang=en,write-auto-sub=
ytdl-format=bestvideo+bestaudio/best

293
script-modules/scroll-list.lua
View File

@ -1,293 +0,0 @@
local mp = require 'mp'
local scroll_list = {
global_style = [[]],
header_style = [[{\q2\fs35\c&00ccff&}]],
list_style = [[{\q2\fs25\c&Hffffff&}]],
wrapper_style = [[{\c&00ccff&\fs16}]],
cursor_style = [[{\c&00ccff&}]],
selected_style = [[{\c&Hfce788&}]],
cursor = [[➤\h]],
indent = [[\h\h\h\h]],
num_entries = 16,
wrap = false,
empty_text = "no entries"
}
--formats strings for ass handling
--this function is based on a similar function from https://github.com/mpv-player/mpv/blob/master/player/lua/console.lua#L110
function scroll_list.ass_escape(str, replace_newline)
if replace_newline == true then replace_newline = "\\\239\187\191n" end
--escape the invalid single characters
str = str:gsub('[\\{}\n]', {
-- There is no escape for '\' in ASS (I think?) but '\' is used verbatim if
-- it isn't followed by a recognised character, so add a zero-width
-- non-breaking space
['\\'] = '\\\239\187\191',
['{'] = '\\{',
['}'] = '\\}',
-- Precede newlines with a ZWNBSP to prevent ASS's weird collapsing of
-- consecutive newlines
['\n'] = '\239\187\191\\N',
})
-- Turn leading spaces into hard spaces to prevent ASS from stripping them
str = str:gsub('\\N ', '\\N\\h')
str = str:gsub('^ ', '\\h')
if replace_newline then
str = str:gsub("\\N", replace_newline)
end
return str
end
--format and return the header string
function scroll_list:format_header_string(str)
return str
end
--appends the entered text to the overlay
function scroll_list:append(text)
if text == nil then return end
self.ass.data = self.ass.data .. text
end
--appends a newline character to the osd
function scroll_list:newline()
self.ass.data = self.ass.data .. '\\N'
end
--re-parses the list into an ass string
--if the list is closed then it flags an update on the next open
function scroll_list:update()
if self.hidden then self.flag_update = true
else self:update_ass() end
end
--prints the header to the overlay
function scroll_list:format_header()
self:append(self.header_style)
self:append(self:format_header_string(self.header))
self:newline()
end
--formats each line of the list and prints it to the overlay
function scroll_list:format_line(index, item)
self:append(self.list_style)
if index == self.selected then self:append(self.cursor_style..self.cursor..self.selected_style)
else self:append(self.indent) end
self:append(item.style)
self:append(item.ass)
self:newline()
end
--refreshes the ass text using the contents of the list
function scroll_list:update_ass()
self.ass.data = self.global_style
self:format_header()
if #self.list < 1 then
self:append(self.empty_text)
self.ass:update()
return
end
local start = 1
local finish = start+self.num_entries-1
--handling cursor positioning
local mid = math.ceil(self.num_entries/2)+1
if self.selected+mid > finish then
local offset = self.selected - finish + mid
--if we've overshot the end of the list then undo some of the offset
if finish + offset > #self.list then
offset = offset - ((finish+offset) - #self.list)
end
start = start + offset
finish = finish + offset
end
--making sure that we don't overstep the boundaries
if start < 1 then start = 1 end
local overflow = finish < #self.list
--this is necessary when the number of items in the dir is less than the max
if not overflow then finish = #self.list end
--adding a header to show there are items above in the list
if start > 1 then self:append(self.wrapper_style..(start-1)..' item(s) above\\N\\N') end
for i=start, finish do
self:format_line(i, self.list[i])
end
if overflow then self:append('\\N'..self.wrapper_style..#self.list-finish..' item(s) remaining') end
self.ass:update()
end
--moves the selector down the list
function scroll_list:scroll_down()
if self.selected < #self.list then
self.selected = self.selected + 1
self:update_ass()
elseif self.wrap then
self.selected = 1
self:update_ass()
end
end
--moves the selector up the list
function scroll_list:scroll_up()
if self.selected > 1 then
self.selected = self.selected - 1
self:update_ass()
elseif self.wrap then
self.selected = #self.list
self:update_ass()
end
end
--moves the selector to the list next page
function scroll_list:move_pagedown()
if #self.list > self.num_entries then
self.selected = self.selected + self.num_entries
if self.selected > #self.list then self.selected = #self.list end
self:update_ass()
end
end
--moves the selector to the list previous page
function scroll_list:move_pageup()
if #self.list > self.num_entries then
self.selected = self.selected - self.num_entries
if self.selected < 1 then self.selected = 1 end
self:update_ass()
end
end
--moves the selector to the list begin
function scroll_list:move_begin()
if #self.list > 1 then
self.selected = 1
self:update_ass()
end
end
--moves the selector to the list end
function scroll_list:move_end()
if #self.list > 1 then
self.selected = #self.list
self:update_ass()
end
end
--adds the forced keybinds
function scroll_list:add_keybinds()
for _,v in ipairs(self.keybinds) do
mp.add_forced_key_binding(v[1], 'dynamic/'..self.ass.id..'/'..v[2], v[3], v[4])
end
end
--removes the forced keybinds
function scroll_list:remove_keybinds()
for _,v in ipairs(self.keybinds) do
mp.remove_key_binding('dynamic/'..self.ass.id..'/'..v[2])
end
end
--opens the list and sets the hidden flag
function scroll_list:open_list()
self.hidden = false
if not self.flag_update then self.ass:update()
else self.flag_update = false ; self:update_ass() end
end
--closes the list and sets the hidden flag
function scroll_list:close_list()
self.hidden = true
self.ass:remove()
end
--modifiable function that opens the list
function scroll_list:open()
if self.hidden then self:add_keybinds() end
self:open_list()
end
--modifiable function that closes the list
function scroll_list:close()
self:remove_keybinds()
self:close_list()
end
--toggles the list
function scroll_list:toggle()
if self.hidden then self:open()
else self:close() end
end
--clears the list in-place
function scroll_list:clear()
local i = 1
while self.list[i] do
self.list[i] = nil
i = i + 1
end
end
--added alias for ipairs(list.list) for lua 5.1
function scroll_list:ipairs()
return ipairs(self.list)
end
--append item to the end of the list
function scroll_list:insert(item)
self.list[#self.list + 1] = item
end
local metatable = {
__index = function(t, key)
if scroll_list[key] ~= nil then return scroll_list[key]
elseif key == "__current" then return t.list[t.selected]
elseif type(key) == "number" then return t.list[key] end
end,
__newindex = function(t, key, value)
if type(key) == "number" then rawset(t.list, key, value)
else rawset(t, key, value) end
end,
__scroll_list = scroll_list,
__len = function(t) return #t.list end,
__ipairs = function(t) return ipairs(t.list) end
}
--creates a new list object
function scroll_list:new()
local vars
vars = {
ass = mp.create_osd_overlay('ass-events'),
hidden = true,
flag_update = true,
header = "header \\N ----------------------------------------------",
list = {},
selected = 1,
keybinds = {
{'DOWN', 'scroll_down', function() vars:scroll_down() end, {repeatable = true}},
{'UP', 'scroll_up', function() vars:scroll_up() end, {repeatable = true}},
{'PGDWN', 'move_pagedown', function() vars:move_pagedown() end, {}},
{'PGUP', 'move_pageup', function() vars:move_pageup() end, {}},
{'HOME', 'move_begin', function() vars:move_begin() end, {}},
{'END', 'move_end', function() vars:move_end() end, {}},
{'ESC', 'close_browser', function() vars:close() end, {}}
}
}
return setmetatable(vars, metatable)
end
return scroll_list:new()

126
script-modules/user-input-module.lua
View File

@ -1,126 +0,0 @@
--[[
This is a module designed to interface with mpv-user-input
https://github.com/CogentRedTester/mpv-user-input
Loading this script as a module will return a table with two functions to format
requests to get and cancel user-input requests. See the README for details.
Alternatively, developers can just paste these functions directly into their script,
however this is not recommended as there is no guarantee that the formatting of
these requests will remain the same for future versions of user-input.
]]
local API_VERSION = "0.1.0"
local mp = require 'mp'
local msg = require "mp.msg"
local utils = require 'mp.utils'
local mod = {}
local name = mp.get_script_name()
local counter = 1
local function pack(...)
local t = {...}
t.n = select("#", ...)
return t
end
local request_mt = {}
-- ensures the option tables are correctly formatted based on the input
local function format_options(options, response_string)
return {
response = response_string,
version = API_VERSION,
id = name..'/'..(options.id or ""),
source = name,
request_text = ("[%s] %s"):format(options.source or name, options.request_text or options.text or "requesting user input:"),
default_input = options.default_input,
cursor_pos = tonumber(options.cursor_pos),
queueable = options.queueable and true,
replace = options.replace and true
}
end
-- cancels the request
function request_mt:cancel()
assert(self.uid, "request object missing UID")
mp.commandv("script-message-to", "user_input", "cancel-user-input/uid", self.uid)
end
-- updates the options for the request
function request_mt:update(options)
assert(self.uid, "request object missing UID")
options = utils.format_json( format_options(options) )
mp.commandv("script-message-to", "user_input", "update-user-input/uid", self.uid, options)
end
-- sends a request to ask the user for input using formatted options provided
-- creates a script message to recieve the response and call fn
function mod.get_user_input(fn, options, ...)
options = options or {}
local response_string = name.."/__user_input_request/"..counter
counter = counter + 1
local request = {
uid = response_string,
passthrough_args = pack(...),
callback = fn,
pending = true
}
-- create a callback for user-input to respond to
mp.register_script_message(response_string, function(response)
mp.unregister_script_message(response_string)
request.pending = false
response = utils.parse_json(response)
request.callback(response.line, response.err, unpack(request.passthrough_args, 1, request.passthrough_args.n))
end)
-- send the input command
options = utils.format_json( format_options(options, response_string) )
mp.commandv("script-message-to", "user_input", "request-user-input", options)
return setmetatable(request, { __index = request_mt })
end
-- runs the request synchronously using coroutines
-- takes the option table and an optional coroutine resume function
function mod.get_user_input_co(options, co_resume)
local co, main = coroutine.running()
assert(not main and co, "get_user_input_co must be run from within a coroutine")
local uid = {}
local request = mod.get_user_input(function(line, err)
if co_resume then
co_resume(uid, line, err)
else
local success, er = coroutine.resume(co, uid, line, err)
if not success then
msg.warn(debug.traceback(co))
msg.error(er)
end
end
end, options)
-- if the uid was not sent then the coroutine was resumed by the user.
-- we will treat this as a cancellation request
local success, line, err = coroutine.yield(request)
if success ~= uid then
request:cancel()
request.callback = function() end
return nil, "cancelled"
end
return line, err
end
-- sends a request to cancel all input requests with the given id
function mod.cancel_user_input(id)
id = name .. '/' .. (id or "")
mp.commandv("script-message-to", "user_input", "cancel-user-input/id", id)
end
return mod

4
script-opts/thumbfast.conf
View File

@ -6,8 +6,8 @@ thumbnail=
# Maximum thumbnail size in pixels (scaled down to fit)
# Values are scaled when hidpi is enabled
max_height=400
max_width=400
max_height=500
max_width=500
# Overlay id
overlay_id=42

749
scripts/user-input.lua
View File

@ -1,749 +0,0 @@
local mp = require 'mp'
local msg = require 'mp.msg'
local utils = require 'mp.utils'
local options = require 'mp.options'
-- Default options
local opts = {
-- All drawing is scaled by this value, including the text borders and the
-- cursor. Change it if you have a high-DPI display.
scale = 1,
-- Set the font used for the REPL and the console. This probably doesn't
-- have to be a monospaced font.
font = "",
-- Set the font size used for the REPL and the console. This will be
-- multiplied by "scale."
font_size = 16
}
options.read_options(opts, "user_input")
local API_VERSION = "0.1.0"
local API_MAJOR_MINOR = API_VERSION:match("%d+%.%d+")
local co = nil
local queue = {}
local active_ids = {}
local histories = {}
local request = nil
local line = ''
--[[
The below code is a modified implementation of text input from mpv's console.lua:
https://github.com/mpv-player/mpv/blob/7ca14d646c7e405f3fb1e44600e2a67fc4607238/player/lua/console.lua
Modifications:
removed support for log messages, sending commands, tab complete, help commands
removed update timer
Changed esc key to call handle_esc function
handle_esc and handle_enter now resume the main coroutine with a response table
made history specific to request ids
localised all functions - reordered some to fit
keybindings use new names
]]
--
------------------------------START ORIGINAL MPV CODE-----------------------------------
----------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------
-- Copyright (C) 2019 the mpv developers
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted, provided that the above
-- copyright notice and this permission notice appear in all copies.
--
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
-- SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
-- OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
-- CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
local assdraw = require 'mp.assdraw'
local function detect_platform()
local o = {}
-- Kind of a dumb way of detecting the platform but whatever
if mp.get_property_native('options/vo-mmcss-profile', o) ~= o then
return 'windows'
elseif mp.get_property_native('options/macos-force-dedicated-gpu', o) ~= o then
return 'macos'
elseif os.getenv('WAYLAND_DISPLAY') then
return 'wayland'
end
return 'x11'
end
-- Pick a better default font for Windows and macOS
local platform = detect_platform()
if platform == 'windows' then
opts.font = 'Consolas'
elseif platform == 'macos' then
opts.font = 'Menlo'
else
opts.font = 'monospace'
end
local repl_active = false
local insert_mode = false
local cursor = 1
local key_bindings = {}
local global_margin_y = 0
-- Escape a string for verbatim display on the OSD
local function ass_escape(str)
-- There is no escape for '\' in ASS (I think?) but '\' is used verbatim if
-- it isn't followed by a recognised character, so add a zero-width
-- non-breaking space
str = str:gsub('\\', '\\\239\187\191')
str = str:gsub('{', '\\{')
str = str:gsub('}', '\\}')
-- Precede newlines with a ZWNBSP to prevent ASS's weird collapsing of
-- consecutive newlines
str = str:gsub('\n', '\239\187\191\\N')
-- Turn leading spaces into hard spaces to prevent ASS from stripping them
str = str:gsub('\\N ', '\\N\\h')
str = str:gsub('^ ', '\\h')
return str
end
-- Render the REPL and console as an ASS OSD
local function update()
local dpi_scale = mp.get_property_native("display-hidpi-scale", 1.0)
dpi_scale = dpi_scale * opts.scale
local screenx, screeny, aspect = mp.get_osd_size()
screenx = screenx / dpi_scale
screeny = screeny / dpi_scale
-- Clear the OSD if the REPL is not active
if not repl_active then
mp.set_osd_ass(screenx, screeny, '')
return
end
local ass = assdraw.ass_new()
local style = '{\\r' .. '\\1a&H00&\\3a&H00&\\4a&H99&' ..
'\\1c&Heeeeee&\\3c&H111111&\\4c&H000000&' .. '\\fn' ..
opts.font .. '\\fs' .. opts.font_size ..
'\\bord1\\xshad0\\yshad1\\fsp0\\q1}'
local queue_style = '{\\r' .. '\\1a&H00&\\3a&H00&\\4a&H99&' ..
'\\1c&Heeeeee&\\3c&H111111&\\4c&H000000&' .. '\\fn' ..
opts.font .. '\\fs' .. opts.font_size ..
'\\c&H66ccff&' ..
'\\bord1\\xshad0\\yshad1\\fsp0\\q1}'
-- Create the cursor glyph as an ASS drawing. ASS will draw the cursor
-- inline with the surrounding text, but it sets the advance to the width
-- of the drawing. So the cursor doesn't affect layout too much, make it as
-- thin as possible and make it appear to be 1px wide by giving it 0.5px
-- horizontal borders.
local cheight = opts.font_size * 8
local cglyph = '{\\r' .. '\\1a&H44&\\3a&H44&\\4a&H99&' ..
'\\1c&Heeeeee&\\3c&Heeeeee&\\4c&H000000&' ..
'\\xbord0.5\\ybord0\\xshad0\\yshad1\\p4\\pbo24}' ..
'm 0 0 l 1 0 l 1 ' .. cheight .. ' l 0 ' .. cheight ..
'{\\p0}'
local before_cur = ass_escape(line:sub(1, cursor - 1))
local after_cur = ass_escape(line:sub(cursor))
ass:new_event()
ass:an(1)
ass:pos(2, screeny - 2 - global_margin_y * screeny)
if (#queue == 2) then
ass:append(queue_style ..
string.format("There is 1 more request queued\\N"))
elseif (#queue > 2) then
ass:append(queue_style ..
string.format("There are %d more requests queued\\N",
#queue - 1))
end
ass:append(style .. request.text .. '\\N')
ass:append('> ' .. before_cur)
ass:append(cglyph)
ass:append(style .. after_cur)
-- Redraw the cursor with the REPL text invisible. This will make the
-- cursor appear in front of the text.
ass:new_event()
ass:an(1)
ass:pos(2, screeny - 2)
ass:append(style .. '{\\alpha&HFF&}> ' .. before_cur)
ass:append(cglyph)
ass:append(style .. '{\\alpha&HFF&}' .. after_cur)
mp.set_osd_ass(screenx, screeny, ass.text)
end
-- Naive helper function to find the next UTF-8 character in 'str' after 'pos'
-- by skipping continuation bytes. Assumes 'str' contains valid UTF-8.
local function next_utf8(str, pos)
if pos > str:len() then return pos end
repeat
pos = pos + 1
until pos > str:len() or str:byte(pos) < 0x80 or
str:byte(pos) > 0xbf
return pos
end
-- As above, but finds the previous UTF-8 charcter in 'str' before 'pos'
local function prev_utf8(str, pos)
if pos <= 1 then return pos end
repeat
pos = pos - 1
until pos <= 1 or str:byte(pos) < 0x80 or str:byte(pos) >
0xbf
return pos
end
-- Insert a character at the current cursor position (any_unicode)
local function handle_char_input(c)
if insert_mode then
line = line:sub(1, cursor - 1) .. c .. line:sub(next_utf8(line, cursor))
else
line = line:sub(1, cursor - 1) .. c .. line:sub(cursor)
end
cursor = cursor + #c
update()
end
-- Remove the character behind the cursor (Backspace)
local function handle_backspace()
if cursor <= 1 then return end
local prev = prev_utf8(line, cursor)
line = line:sub(1, prev - 1) .. line:sub(cursor)
cursor = prev
update()
end
-- Remove the character in front of the cursor (Del)
local function handle_del()
if cursor > line:len() then return end
line = line:sub(1, cursor - 1) .. line:sub(next_utf8(line, cursor))
update()
end
-- Toggle insert mode (Ins)
local function handle_ins() insert_mode = not insert_mode end
-- Move the cursor to the next character (Right)
local function next_char(amount)
cursor = next_utf8(line, cursor)
update()
end
-- Move the cursor to the previous character (Left)
local function prev_char(amount)
cursor = prev_utf8(line, cursor)
update()
end
-- Clear the current line (Ctrl+C)
local function clear()
line = ''
cursor = 1
insert_mode = false
request.history.pos = #request.history.list + 1
update()
end
-- Close the REPL if the current line is empty, otherwise do nothing (Ctrl+D)
local function maybe_exit()
if line == '' then
else
handle_del()
end
end
local function handle_esc() coroutine.resume(co, { line = nil, err = "exited" }) end
-- Run the current command and clear the line (Enter)
local function handle_enter()
if request.history.list[#request.history.list] ~= line and line ~= "" then
request.history.list[#request.history.list + 1] = line
end
coroutine.resume(co, { line = line })
end
-- Go to the specified position in the command history
local function go_history(new_pos)
local old_pos = request.history.pos
request.history.pos = new_pos
-- Restrict the position to a legal value
if request.history.pos > #request.history.list + 1 then
request.history.pos = #request.history.list + 1
elseif request.history.pos < 1 then
request.history.pos = 1
end
-- Do nothing if the history position didn't actually change
if request.history.pos == old_pos then return end
-- If the user was editing a non-history line, save it as the last history
-- entry. This makes it much less frustrating to accidentally hit Up/Down
-- while editing a line.
if old_pos == #request.history.list + 1 and line ~= '' and
request.history.list[#request.history.list] ~= line then
request.history.list[#request.history.list + 1] = line
end
-- Now show the history line (or a blank line for #history + 1)
if request.history.pos <= #request.history.list then
line = request.history.list[request.history.pos]
else
line = ''
end
cursor = line:len() + 1
insert_mode = false
update()
end
-- Go to the specified relative position in the command history (Up, Down)
local function move_history(amount) go_history(request.history.pos + amount) end
-- Go to the first command in the command history (PgUp)
local function handle_pgup() go_history(1) end
-- Stop browsing history and start editing a blank line (PgDown)
local function handle_pgdown() go_history(#request.history.list + 1) end
-- Move to the start of the current word, or if already at the start, the start
-- of the previous word. (Ctrl+Left)
local function prev_word()
-- This is basically the same as next_word() but backwards, so reverse the
-- string in order to do a "backwards" find. This wouldn't be as annoying
-- to do if Lua didn't insist on 1-based indexing.
cursor = line:len() -
select(2, line:reverse()
:find('%s*[^%s]*', line:len() - cursor + 2)) + 1
update()
end
-- Move to the end of the current word, or if already at the end, the end of
-- the next word. (Ctrl+Right)
local function next_word()
cursor = select(2, line:find('%s*[^%s]*', cursor)) + 1
update()
end
-- Move the cursor to the beginning of the line (HOME)
local function go_home()
cursor = 1
update()
end
-- Move the cursor to the end of the line (END)
local function go_end()
cursor = line:len() + 1
update()
end
-- Delete from the cursor to the beginning of the word (Ctrl+Backspace)
local function del_word()
local before_cur = line:sub(1, cursor - 1)
local after_cur = line:sub(cursor)
before_cur = before_cur:gsub('[^%s]+%s*$', '', 1)
line = before_cur .. after_cur
cursor = before_cur:len() + 1
update()
end
-- Delete from the cursor to the end of the word (Ctrl+Del)
local function del_next_word()
if cursor > line:len() then return end
local before_cur = line:sub(1, cursor - 1)
local after_cur = line:sub(cursor)
after_cur = after_cur:gsub('^%s*[^%s]+', '', 1)
line = before_cur .. after_cur
update()
end
-- Delete from the cursor to the end of the line (Ctrl+K)
local function del_to_eol()
line = line:sub(1, cursor - 1)
update()
end
-- Delete from the cursor back to the start of the line (Ctrl+U)
local function del_to_start()
line = line:sub(cursor)
cursor = 1
update()
end
-- Returns a string of UTF-8 text from the clipboard (or the primary selection)
local function get_clipboard(clip)
if platform == 'x11' then
local res = utils.subprocess({
args = {
'xclip', '-selection', clip and 'clipboard' or 'primary', '-out'
},
playback_only = false
})
if not res.error then return res.stdout end
elseif platform == 'wayland' then
local res = utils.subprocess({
args = { 'wl-paste', clip and '-n' or '-np' },
playback_only = false
})
if not res.error then return res.stdout end
elseif platform == 'windows' then
local res = utils.subprocess({
args = {
'powershell', '-NoProfile', '-Command', [[& {
Trap {
Write-Error -ErrorRecord $_
Exit 1
}
$clip = ""
if (Get-Command "Get-Clipboard" -errorAction SilentlyContinue) {
$clip = Get-Clipboard -Raw -Format Text -TextFormatType UnicodeText
} else {
Add-Type -AssemblyName PresentationCore
$clip = [Windows.Clipboard]::GetText()
}
$clip = $clip -Replace "`r",""
$u8clip = [System.Text.Encoding]::UTF8.GetBytes($clip)
[Console]::OpenStandardOutput().Write($u8clip, 0, $u8clip.Length)
}]]
},
playback_only = false
})
if not res.error then return res.stdout end
elseif platform == 'macos' then
local res =
utils.subprocess({ args = { 'pbpaste' }, playback_only = false })
if not res.error then return res.stdout end
end
return ''
end
-- Paste text from the window-system's clipboard. 'clip' determines whether the
-- clipboard or the primary selection buffer is used (on X11 and Wayland only.)
local function paste(clip)
local text = get_clipboard(clip)
local before_cur = line:sub(1, cursor - 1)
local after_cur = line:sub(cursor)
line = before_cur .. text .. after_cur
cursor = cursor + text:len()
update()
end
-- List of input bindings. This is a weird mashup between common GUI text-input
-- bindings and readline bindings.
local function get_bindings()
local bindings = {
{ 'esc', handle_esc }, { 'enter', handle_enter },
{ 'kp_enter', handle_enter },
{ 'shift+enter', function() handle_char_input('\n') end },
{ 'ctrl+j', handle_enter }, { 'ctrl+m', handle_enter },
{ 'bs', handle_backspace }, { 'shift+bs', handle_backspace },
{ 'ctrl+h', handle_backspace }, { 'del', handle_del },
{ 'shift+del', handle_del }, { 'ins', handle_ins },
{ 'shift+ins', function() paste(false) end },
{ 'mbtn_mid', function() paste(false) end },
{ 'left', function() prev_char() end },
{ 'ctrl+b', function() prev_char() end },
{ 'right', function() next_char() end },
{ 'ctrl+f', function() next_char() end },
{ 'up', function() move_history(-1) end },
{ 'ctrl+p', function() move_history(-1) end },
{ 'wheel_up', function() move_history(-1) end },
{ 'down', function() move_history(1) end },
{ 'ctrl+n', function() move_history(1) end },
{ 'wheel_down', function() move_history(1) end },
{ 'wheel_left', function() end }, { 'wheel_right', function() end },
{ 'ctrl+left', prev_word }, { 'alt+b', prev_word },
{ 'ctrl+right', next_word }, { 'alt+f', next_word }, { 'ctrl+a', go_home },
{ 'home', go_home }, { 'ctrl+e', go_end }, { 'end', go_end },
{ 'pgup', handle_pgup }, { 'pgdwn', handle_pgdown }, { 'ctrl+c', clear },
{ 'ctrl+d', maybe_exit }, { 'ctrl+k', del_to_eol },
{ 'ctrl+u', del_to_start }, { 'ctrl+v', function() paste(true) end },
{ 'meta+v', function() paste(true) end }, { 'ctrl+bs', del_word },
{ 'ctrl+w', del_word }, { 'ctrl+del', del_next_word },
{ 'alt+d', del_next_word },
{ 'kp_dec', function() handle_char_input('.') end }
}
for i = 0, 9 do
bindings[#bindings + 1] = {
'kp' .. i, function() handle_char_input('' .. i) end
}
end
return bindings
end
local function text_input(info)
if info.key_text and
(info.event == "press" or info.event == "down" or info.event == "repeat") then
handle_char_input(info.key_text)
end
end
local function define_key_bindings()
if #key_bindings > 0 then return end
for _, bind in ipairs(get_bindings()) do
-- Generate arbitrary name for removing the bindings later.
local name = "_userinput_" .. bind[1]
key_bindings[#key_bindings + 1] = name
mp.add_forced_key_binding(bind[1], name, bind[2], { repeatable = true })
end
mp.add_forced_key_binding("any_unicode", "_userinput_text", text_input,
{ repeatable = true, complex = true })
key_bindings[#key_bindings + 1] = "_userinput_text"
end
local function undefine_key_bindings()
for _, name in ipairs(key_bindings) do mp.remove_key_binding(name) end
key_bindings = {}
end
-- Set the REPL visibility ("enable", Esc)
local function set_active(active)
if active == repl_active then return end
if active then
repl_active = true
insert_mode = false
define_key_bindings()
else
clear()
repl_active = false
undefine_key_bindings()
collectgarbage()
end
update()
end
utils.shared_script_property_observe("osc-margins", function(_, val)
if val then
-- formatted as "%f,%f,%f,%f" with left, right, top, bottom, each
-- value being the border size as ratio of the window size (0.0-1.0)
local vals = {}
for v in string.gmatch(val, "[^,]+") do
vals[#vals + 1] = tonumber(v)
end
global_margin_y = vals[4] -- bottom
else
global_margin_y = 0
end
update()
end)
-- Redraw the REPL when the OSD size changes. This is needed because the
-- PlayRes of the OSD will need to be adjusted.
mp.observe_property('osd-width', 'native', update)
mp.observe_property('osd-height', 'native', update)
mp.observe_property('display-hidpi-scale', 'native', update)
----------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------
-------------------------------END ORIGINAL MPV CODE------------------------------------
--[[
sends a response to the original script in the form of a json string
it is expected that all requests get a response, if the input is nil then err should say why
current error codes are:
exited the user closed the input instead of pressing Enter
already_queued a request with the specified id was already in the queue
cancelled a script cancelled the request
replace replaced by another request
]]
local function send_response(res)
if res.source then
mp.commandv("script-message-to", res.source, res.response,
(utils.format_json(res)))
else
mp.commandv("script-message", res.response, (utils.format_json(res)))
end
end
-- push new request onto the queue
-- if a request with the same id already exists and the queueable flag is not enabled then
-- a nil result will be returned to the function
function push_request(req)
if active_ids[req.id] then
if req.replace then
for i, q_req in ipairs(queue) do
if q_req.id == req.id then
send_response {
err = "replaced",
response = q_req.response,
source = q_req.source
}
queue[i] = req
if i == 1 then request = req end
end
end
update()
return
end
if not req.queueable then
send_response {
err = "already_queued",
response = req.response,
source = req.source
}
return
end
end
table.insert(queue, req)
active_ids[req.id] = (active_ids[req.id] or 0) + 1
if #queue == 1 then coroutine.resume(co) end
update()
end
-- safely removes an item from the queue and updates the set of active requests
function remove_request(index)
local req = table.remove(queue, index)
active_ids[req.id] = active_ids[req.id] - 1
if active_ids[req.id] == 0 then active_ids[req.id] = nil end
return req
end
-- an infinite loop that moves through the request queue
-- uses a coroutine to handle asynchronous operations
local function driver()
while (true) do
while queue[1] do
request = queue[1]
line = request.default_input
cursor = request.cursor_pos
if repl_active then
update()
else
set_active(true)
end
res = coroutine.yield()
if res then
res.source, res.response = request.source, request.response
send_response(res)
remove_request(1)
end
end
set_active(false)
coroutine.yield()
end
end
co = coroutine.create(driver)
-- cancels any input request that returns true for the given predicate function
local function cancel_input_request(pred)
for i = #queue, 1, -1 do
if pred(i) then
req = remove_request(i)
send_response {
err = "cancelled",
response = req.response,
source = req.source
}
-- if we're removing the first item then that means the coroutine is waiting for a response
-- we will need to tell the coroutine to resume, upon which it will move to the next request
-- if there is something in the buffer then save it to the history before erasing it
if i == 1 then
local old_line = line
if old_line ~= "" then
table.insert(histories[req.id].list, old_line)
end
clear()
coroutine.resume(co)
end
end
end
end
mp.register_script_message("cancel-user-input/uid", function(uid)
cancel_input_request(function(i) return queue[i].response == uid end)
end)
-- removes all requests with the specified id from the queue
mp.register_script_message("cancel-user-input/id", function(id)
cancel_input_request(function(i) return queue[i].id == id end)
end)
-- ensures a request has the correct fields and is correctly formatted
local function format_request_fields(req)
assert(req.version, "input requests require an API version string")
if not string.find(req.version, API_MAJOR_MINOR, 1, true) then
error(
("input request has invalid version: expected %s.x, got %s"):format(
API_MAJOR_MINOR, req.version))
end
assert(req.response, "input requests require a response string")
assert(req.id, "input requests require an id string")
req.text = ass_escape(req.request_text or "")
req.default_input = req.default_input or ""
req.cursor_pos = tonumber(req.cursor_pos) or 1
req.id = req.id or "mpv"
if req.cursor_pos ~= 1 then
if req.cursor_pos < 1 then
req.cursor_pos = 1
elseif req.cursor_pos > #req.default_input then
req.cursor_pos = #req.default_input + 1
end
end
if not histories[req.id] then histories[req.id] = { pos = 1, list = {} } end
req.history = histories[req.id]
return req
end
-- updates the fields of a specific request
mp.register_script_message("update-user-input/uid", function(uid, req_opts)
req_opts = utils.parse_json(req_opts)
req_opts.response = uid
for i, req in ipairs(queue) do
if req.response == uid then
local success, result = pcall(format_request_fields, req_opts)
if not success then return msg.error(result) end
queue[i] = result
if i == 1 then request = queue[1] end
update()
return
end
end
end)
-- the function that parses the input requests
local function input_request(req)
req = format_request_fields(req)
push_request(req)
end
-- script message to recieve input requests, get-user-input.lua acts as an interface to call this script message
mp.register_script_message("request-user-input", function(req)
msg.debug(req)
req = utils.parse_json(req)
local success, err = pcall(input_request, req)
if not success then
send_response { err = err, response = req.response, source = req.source }
msg.error(err)
end
end)

373
scripts/youtube-search.lua
View File

@ -1,373 +0,0 @@
--[[
This script allows users to search and open youtube results from within mpv.
Available at: https://github.com/CogentRedTester/mpv-scripts
Users can open the search page with Y, and use Y again to open a search.
Alternatively, Ctrl+y can be used at any time to open a search.
Esc can be used to close the page.
Enter will open the selected item, Shift+Enter will append the item to the playlist.
This script requires that my other scripts `scroll-list` and `user-input` be installed.
scroll-list.lua and user-input-module.lua must be in the ~~/script-modules/ directory,
while user-input.lua should be loaded by mpv normally.
https://github.com/CogentRedTester/mpv-scroll-list
https://github.com/CogentRedTester/mpv-user-input
This script also requires a youtube API key to be entered.
The API key must be passed to the `API_key` script-opt.
A personal API key is free and can be created from:
https://console.developers.google.com/apis/api/youtube.googleapis.com/
The script also requires that curl be in the system path.
An alternative to using the official youtube API is to use Invidious.
This script has experimental support for Invidious searches using the 'invidious',
'API_path', and 'frontend' options. API_path refers to the url of the API the
script uses, Invidious API paths are usually in the form:
https://domain.name/api/v1/
The frontend option is the url to actualy try to load videos from. This
can probably be the same as the above url:
https://domain.name
Since the url syntax seems to be identical between Youtube and Invidious,
it should be possible to mix these options, a.k.a. using the Google
API to get videos from an Invidious frontend, or to use an Invidious
API to get videos from Youtube.
The 'invidious' option tells the script that the API_path is for an
Invidious path. This is to support other possible API options in the future.
]]
--
local mp = require "mp"
local msg = require "mp.msg"
local utils = require "mp.utils"
local opts = require "mp.options"
package.path = mp.command_native({ "expand-path", "~~/script-modules/?.lua;" }) ..
package.path
local ui = require "user-input-module"
local list = require "scroll-list"
local o = {
API_key = "AIzaSyAiXDAueA9Kn_hbqxb5lN38vFI3IviA3gg",
-- number of search results to show in the list
num_results = 40,
-- the url to send API calls to
API_path = "https://www.googleapis.com/youtube/v3/",
-- attempt this API if the default fails
fallback_API_path = "",
-- the url to load videos from
frontend = "https://www.youtube.com",
-- use invidious API calls
invidious = false,
-- whether the fallback uses invidious as well
fallback_invidious = false
}
opts.read_options(o)
-- ensure the URL options are properly formatted
local function format_options()
if o.API_path:sub(-1) ~= "/" then o.API_path = o.API_path .. "/" end
if o.fallback_API_path:sub(-1) ~= "/" then
o.fallback_API_path = o.fallback_API_path .. "/"
end
if o.frontend:sub(-1) == "/" then o.frontend = o.frontend:sub(1, -2) end
end
format_options()
list.header =
("%s Search: \\N-------------------------------------------------"):format(
o.invidious and "Invidious" or "Youtube")
list.num_entries = 17
list.list_style = [[{\fs10}\N{\q2\fs25\c&Hffffff&}]]
list.empty_text = "enter search query"
local ass_escape = list.ass_escape
-- encodes a string so that it uses url percent encoding
-- this function is based on code taken from here: https://rosettacode.org/wiki/URL_encoding#Lua
local function encode_string(str)
if type(str) ~= "string" then return str end
local output, t = str:gsub("[^%w]", function(char)
return string.format("%%%X", string.byte(char))
end)
return output
end
-- convert HTML character codes to the correct characters
local function html_decode(str)
if type(str) ~= "string" then return str end
return str:gsub("&(#?)(%w-);", function(is_ascii, code)
if is_ascii == "#" then return string.char(tonumber(code)) end
if code == "amp" then return "&" end
if code == "quot" then return '"' end
if code == "apos" then return "'" end
if code == "lt" then return "<" end
if code == "gt" then return ">" end
return nil
end)
end
-- creates a formatted results table from an invidious API call
function format_invidious_results(response)
if not response then return nil end
local results = {}
for i, item in ipairs(response) do
if i > o.num_results then break end
local t = {}
table.insert(results, t)
t.title = html_decode(item.title)
t.channelTitle = html_decode(item.author)
if item.type == "video" then
t.type = "video"
t.id = item.videoId
elseif item.type == "playlist" then
t.type = "playlist"
t.id = item.playlistId
elseif item.type == "channel" then
t.type = "channel"
t.id = item.authorId
t.title = t.channelTitle
end
end
return results
end
-- creates a formatted results table from a youtube API call
function format_youtube_results(response)
if not response or not response.items then return nil end
local results = {}
for _, item in ipairs(response.items) do
local t = {}
table.insert(results, t)
t.title = html_decode(item.snippet.title)
t.channelTitle = html_decode(item.snippet.channelTitle)
if item.id.kind == "youtube#video" then
t.type = "video"
t.id = item.id.videoId
elseif item.id.kind == "youtube#playlist" then
t.type = "playlist"
t.id = item.id.playlistId
elseif item.id.kind == "youtube#channel" then
t.type = "channel"
t.id = item.id.channelId
end
end
return results
end
-- sends an API request
local function send_request(type, queries, API_path)
local url = (API_path or o.API_path) .. type
url = url .. "?"
for key, value in pairs(queries) do
msg.verbose(key, value)
url = url .. "&" .. key .. "=" .. encode_string(value)
end
msg.debug(url)
local request = mp.command_native({
name = "subprocess",
capture_stdout = true,
capture_stderr = true,
playback_only = false,
args = { "curl", url }
})
local response = utils.parse_json(request.stdout)
msg.trace(utils.to_string(request))
if request.status ~= 0 then
msg.error(request.stderr)
return nil
end
if not response then
msg.error("Could not parse response:")
msg.error(request.stdout)
return nil
end
if response.error then
msg.error(request.stdout)
return nil
end
return response
end
-- sends a search API request - handles Google/Invidious API differences
local function search_request(queries, API_path, invidious)
list.header =
("%s Search: %s\\N-------------------------------------------------"):format(
invidious and "Invidious" or "Youtube", ass_escape(queries.q, true))
list.list = {}
list.empty_text = "~"
list:update()
local results = {}
-- we need to modify the returned results so that the rest of the script can read it
if invidious then
-- Invidious searches are done with pages rather than a max result number
local page = 1
while #results < o.num_results do
queries.page = page
local response = send_request("search", queries, API_path)
response = format_invidious_results(response)
if not response then
msg.warn("Search did not return a results list");
return
end
if #response == 0 then break end
for _, item in ipairs(response) do
table.insert(results, item)
end
page = page + 1
end
else
local response = send_request("search", queries, API_path)
results = format_youtube_results(response)
end
-- print error messages to console if the API request fails
if not results then
msg.warn("Search did not return a results list")
return
end
list.empty_text = "no results"
return results
end
local function insert_video(item)
list:insert({
ass = ("%s {\\c&aaaaaa&}%s"):format(ass_escape(item.title),
ass_escape(item.channelTitle)),
url = ("%s/watch?v=%s"):format(o.frontend, item.id)
})
end
local function insert_playlist(item)
list:insert({
ass = ("🖿 %s {\\c&aaaaaa&}%s"):format(ass_escape(item.title),
ass_escape(item.channelTitle)),
url = ("%s/playlist?list=%s"):format(o.frontend, item.id)
})
end
local function insert_channel(item)
list:insert({
ass = ("👤 %s"):format(ass_escape(item.title)),
url = ("%s/channel/%s"):format(o.frontend, item.id)
})
end
local function reset_list()
list.selected = 1
list:clear()
end
-- creates the search request queries depending on what API we're using
local function get_search_queries(query, invidious)
if invidious then
return { q = query, type = "all", page = 1 }
else
return {
key = o.API_key,
q = query,
part = "id,snippet",
maxResults = o.num_results
}
end
end
local function search(query)
local response = search_request(get_search_queries(query, o.invidious),
o.API_path, o.invidious)
if not response and o.fallback_API_path ~= "/" then
msg.info("search failed - attempting fallback")
response = search_request(
get_search_queries(query, o.fallback_invidious),
o.fallback_API_path, o.fallback_invidious)
end
if not response then return end
reset_list()
for _, item in ipairs(response) do
if item.type == "video" then
insert_video(item)
elseif item.type == "playlist" then
insert_playlist(item)
elseif item.type == "channel" then
insert_channel(item)
end
end
list:update()
list:open()
end
local function play_result(flag)
if not list[list.selected] then return end
local url = list[list.selected].url
mp.msg.info("URL: " .. url)
mp.msg.info("Flag: " .. flag)
if flag == "new_window" then
mp.commandv("run", "mpv", url);
return
end
mp.commandv("loadfile", url, flag)
if flag == "replace" then
list:close()
else
mp.commandv("script-message", "add_to_youtube_queue",
list[list.selected].url, 1)
end
end
table.insert(list.keybinds,
{ "ENTER", "play", function() play_result("replace") end, {} })
table.insert(list.keybinds, {
"Ctrl+ENTER", "play_append", function() play_result("append-play") end, {}
})
table.insert(list.keybinds, {
"Ctrl+Shift+ENTER", "play_new_window",
function() play_result("new_window") end, {}
})
local function open_search_input()
ui.get_user_input(function(input)
if not input then return end
search(input)
end, { request_text = "Enter Query:" })
end
mp.add_key_binding("Ctrl+y", "yt", open_search_input)
mp.add_key_binding("Y", "youtube-search", function()
if not list.hidden then
open_search_input()
else
list:open()
if #list.list == 0 then open_search_input() end
end
end)