1357 lines
40 KiB
Lua
1357 lines
40 KiB
Lua
--[[
|
||
Copyright (C) 2020 Ren Tatsumoto
|
||
|
||
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 <https://www.gnu.org/licenses/>.
|
||
|
||
Requirements:
|
||
* mpv >= 0.32.0
|
||
* AnkiConnect
|
||
* curl
|
||
* xclip (when running X11)
|
||
* wl-copy (when running Wayland)
|
||
|
||
Usage:
|
||
1. Change `config` according to your needs
|
||
* Config path: ~/.config/mpv/script-opts/subs2srs.conf
|
||
* Config file isn't created automatically.
|
||
|
||
2. Open a video
|
||
|
||
3. Use key bindings to manipulate the script
|
||
* Open mpvacious menu - `a`
|
||
* Create a note from the current subtitle line - `Ctrl + e`
|
||
|
||
For complete usage guide, see <https://github.com/Ajatt-Tools/mpvacious/blob/master/README.md>
|
||
]]
|
||
|
||
local config = {
|
||
-- Common
|
||
autoclip = false, -- enable copying subs to the clipboard when mpv starts
|
||
nuke_spaces = false, -- remove all spaces from exported anki cards
|
||
clipboard_trim_enabled = true, -- remove unnecessary characters from strings before copying to the clipboard
|
||
use_ffmpeg = false, -- if set to true, use ffmpeg to create audio clips and snapshots. by default use mpv.
|
||
snapshot_format = "webp", -- webp or jpg
|
||
snapshot_quality = 15, -- from 0=lowest to 100=highest
|
||
snapshot_width = -2, -- a positive integer or -2 for auto
|
||
snapshot_height = 200, -- same
|
||
audio_format = "opus", -- opus or mp3
|
||
audio_bitrate = "18k", -- from 16k to 32k
|
||
audio_padding = 0.12, -- Set a pad to the dialog timings. 0.5 = audio is padded by .5 seconds. 0 = disable.
|
||
tie_volumes = false, -- if set to true, the volume of the outputted audio file depends on the volume of the player at the time of export
|
||
menu_font_size = 25,
|
||
|
||
-- Custom encoding args
|
||
ffmpeg_audio_args = '-af silenceremove=1:0:-50dB',
|
||
mpv_audio_args = '--af-append=silenceremove=1:0:-50dB',
|
||
|
||
-- Anki
|
||
create_deck = false, -- automatically create a deck for new cards
|
||
allow_duplicates = false, -- allow making notes with the same sentence field
|
||
deck_name = "Learning", -- name of the deck for new cards
|
||
model_name = "Japanese sentences", -- Tools -> Manage note types
|
||
sentence_field = "SentKanji",
|
||
audio_field = "SentAudio",
|
||
image_field = "Image",
|
||
append_media = true, -- True to append video media after existing data, false to insert media before
|
||
|
||
-- Note tagging
|
||
-- The tag(s) added to new notes. Spaces separate multiple tags.
|
||
-- Change to "" to disable tagging completely.
|
||
-- The following substitutions are supported:
|
||
-- %n - the name of the video
|
||
-- %t - timestamp
|
||
-- %d - episode number (if none found, returns nothing)
|
||
-- %e - SUBS2SRS_TAGS environment variable
|
||
note_tag = "subs2srs %n",
|
||
tag_nuke_brackets = true, -- delete all text inside brackets before substituting filename into tag
|
||
tag_nuke_parentheses = false, -- delete all text inside parentheses before substituting filename into tag
|
||
tag_del_episode_num = true, -- delete the episode number if found
|
||
tag_del_after_episode_num = true, -- delete everything after the found episode number (does nothing if tag_del_episode_num is disabled)
|
||
tag_filename_lowercase = false, -- convert filename to lowercase for tagging.
|
||
|
||
-- Misc info
|
||
miscinfo_enable = true,
|
||
miscinfo_field = "Notes", -- misc notes and source information field
|
||
miscinfo_format = "%n EP%d (%t)", -- format string to use for the miscinfo_field, accepts note_tag-style format strings
|
||
|
||
-- Forvo support
|
||
use_forvo = "yes", -- 'yes', 'no', 'always'
|
||
vocab_field = "VocabKanji", -- target word field
|
||
vocab_audio_field = "VocabAudio", -- target word audio
|
||
}
|
||
|
||
-- Defines config profiles
|
||
-- Each name references a file in ~/.config/mpv/script-opts/*.conf
|
||
-- Profiles themselves are defined in ~/.config/mpv/script-opts/subs2srs_profiles.conf
|
||
local profiles = {
|
||
profiles = "subs2srs,subs2srs_english",
|
||
active = "subs2srs",
|
||
}
|
||
|
||
package.path = package.path .. ";/Users/flurry/.config/mpv/scripts/?.lua"
|
||
|
||
local mp = require('mp')
|
||
local utils = require('mp.utils')
|
||
local msg = require('mp.msg')
|
||
local config_manager = require('config')
|
||
local encoder = require('encoder')
|
||
|
||
-- namespaces
|
||
local subs
|
||
local clip_autocopy
|
||
local menu
|
||
local platform
|
||
local append_forvo_pronunciation
|
||
|
||
-- classes
|
||
local Subtitle
|
||
|
||
------------------------------------------------------------
|
||
-- utility functions
|
||
|
||
local unpack = unpack and unpack or table.unpack
|
||
|
||
---Returns true if table contains element. Returns false otherwise.
|
||
---@param table table
|
||
---@param element any
|
||
---@return boolean
|
||
function table.contains(table, element)
|
||
for _, value in pairs(table) do
|
||
if value == element then
|
||
return true
|
||
end
|
||
end
|
||
return false
|
||
end
|
||
|
||
---Returns the largest numeric index.
|
||
---@param table table
|
||
---@return number
|
||
function table.max_num(table)
|
||
local max = table[1]
|
||
for _, value in ipairs(table) do
|
||
if value > max then
|
||
max = value
|
||
end
|
||
end
|
||
return max
|
||
end
|
||
|
||
---Returns a value for the given key. If key is not available then returns default value 'nil'.
|
||
---@param table table
|
||
---@param key string
|
||
---@param default any
|
||
---@return any
|
||
function table.get(table, key, default)
|
||
if table[key] == nil then
|
||
return default or 'nil'
|
||
else
|
||
return table[key]
|
||
end
|
||
end
|
||
|
||
local function is_empty(var)
|
||
return var == nil or var == '' or (type(var) == 'table' and next(var) == nil)
|
||
end
|
||
|
||
local function is_running_windows()
|
||
return mp.get_property('options/vo-mmcss-profile') ~= nil
|
||
end
|
||
|
||
local function is_running_macOS()
|
||
return mp.get_property('options/cocoa-force-dedicated-gpu') ~= nil
|
||
end
|
||
|
||
local function is_running_wayland()
|
||
return os.getenv('WAYLAND_DISPLAY') ~= nil
|
||
end
|
||
|
||
local function contains_non_latin_letters(str)
|
||
return str:match("[^%c%p%s%w]")
|
||
end
|
||
|
||
local function capitalize_first_letter(string)
|
||
return string:gsub("^%l", string.upper)
|
||
end
|
||
|
||
local function notify(message, level, duration)
|
||
level = level or 'info'
|
||
duration = duration or 1
|
||
msg[level](message)
|
||
mp.osd_message(message, duration)
|
||
end
|
||
|
||
local escape_special_characters
|
||
do
|
||
local entities = {
|
||
['&'] = '&',
|
||
['"'] = '"',
|
||
["'"] = ''',
|
||
['<'] = '<',
|
||
['>'] = '>',
|
||
}
|
||
escape_special_characters = function(s)
|
||
return s:gsub('[&"\'<>]', entities)
|
||
end
|
||
end
|
||
|
||
local function remove_extension(filename)
|
||
return filename:gsub('%.%w+$', '')
|
||
end
|
||
|
||
local function remove_special_characters(str)
|
||
return str:gsub('[%c%p%s]', ''):gsub(' ', '')
|
||
end
|
||
|
||
local function remove_text_in_brackets(str)
|
||
return str:gsub('%b[]', ''):gsub('【.-】', '')
|
||
end
|
||
|
||
local function remove_filename_text_in_parentheses(str)
|
||
return str:gsub('%b()', ''):gsub('（.-）', '')
|
||
end
|
||
|
||
local function remove_common_resolutions(str)
|
||
-- Also removes empty leftover parentheses and brackets.
|
||
return str:gsub("2160p", ""):gsub("1080p", ""):gsub("720p", ""):gsub("576p", ""):gsub("480p", ""):gsub("%(%)", ""):gsub("%[%]", "")
|
||
end
|
||
|
||
local function remove_text_in_parentheses(str)
|
||
-- Remove text like （泣き声） or （ドアの開く音）
|
||
-- No deletion is performed if there's no text after the parentheses.
|
||
-- Note: the modifier `-´ matches zero or more occurrences.
|
||
-- However, instead of matching the longest sequence, it matches the shortest one.
|
||
return str:gsub('(%b())(.)', '%2'):gsub('(（.-）)(.)', '%2')
|
||
end
|
||
|
||
local function remove_newlines(str)
|
||
return str:gsub('[\n\r]+', ' ')
|
||
end
|
||
|
||
local function remove_leading_trailing_spaces(str)
|
||
return str:gsub('^%s*(.-)%s*$', '%1')
|
||
end
|
||
|
||
local function remove_leading_trailing_dashes(str)
|
||
return str:gsub('^[%-_]*(.-)[%-_]*$', '%1')
|
||
end
|
||
|
||
local function remove_all_spaces(str)
|
||
return str:gsub('%s*', '')
|
||
end
|
||
|
||
local function remove_spaces(str)
|
||
if config.nuke_spaces == true and contains_non_latin_letters(str) then
|
||
return remove_all_spaces(str)
|
||
else
|
||
return remove_leading_trailing_spaces(str)
|
||
end
|
||
end
|
||
|
||
local function trim(str)
|
||
str = remove_spaces(str)
|
||
str = remove_text_in_parentheses(str)
|
||
str = remove_newlines(str)
|
||
return str
|
||
end
|
||
|
||
local function copy_to_clipboard(_, text)
|
||
if not is_empty(text) then
|
||
text = config.clipboard_trim_enabled and trim(text) or remove_newlines(text)
|
||
platform.copy_to_clipboard(text)
|
||
end
|
||
end
|
||
|
||
local function copy_sub_to_clipboard()
|
||
copy_to_clipboard("copy-on-demand", mp.get_property("sub-text"))
|
||
end
|
||
|
||
local function human_readable_time(seconds)
|
||
if type(seconds) ~= 'number' or seconds < 0 then
|
||
return 'empty'
|
||
end
|
||
|
||
local parts = {
|
||
h = math.floor(seconds / 3600),
|
||
m = math.floor(seconds / 60) % 60,
|
||
s = math.floor(seconds % 60),
|
||
ms = math.floor((seconds * 1000) % 1000),
|
||
}
|
||
|
||
local ret = string.format("%02dm%02ds%03dms", parts.m, parts.s, parts.ms)
|
||
|
||
if parts.h > 0 then
|
||
ret = string.format('%dh%s', parts.h, ret)
|
||
end
|
||
|
||
return ret
|
||
end
|
||
|
||
local function subprocess(args, completion_fn)
|
||
-- if `completion_fn` is passed, the command is ran asynchronously,
|
||
-- and upon completion, `completion_fn` is called to process the results.
|
||
local command_native = type(completion_fn) == 'function' and mp.command_native_async or mp.command_native
|
||
local command_table = {
|
||
name = "subprocess",
|
||
playback_only = false,
|
||
capture_stdout = true,
|
||
args = args
|
||
}
|
||
return command_native(command_table, completion_fn)
|
||
end
|
||
|
||
local codec_support = (function()
|
||
return {
|
||
snapshot = {
|
||
libwebp = false,
|
||
mjpeg = false,
|
||
},
|
||
audio = {
|
||
libmp3lame = false,
|
||
libopus = false,
|
||
},
|
||
}
|
||
end)()
|
||
|
||
local function warn_formats(osd)
|
||
if config.use_ffmpeg then
|
||
return
|
||
end
|
||
for type, codecs in pairs(codec_support) do
|
||
for codec, supported in pairs(codecs) do
|
||
if not supported and config[type .. '_codec'] == codec then
|
||
osd:red('warning: '):newline()
|
||
osd:tab():text(string.format("your version of mpv does not support %s.", codec)):newline()
|
||
osd:tab():text(string.format("mpvacious won't be able to create %s files.", type)):newline()
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
local function ensure_deck()
|
||
if config.create_deck == true then
|
||
ankiconnect.create_deck(config.deck_name)
|
||
end
|
||
end
|
||
|
||
local function load_next_profile()
|
||
config_manager.next_profile()
|
||
ensure_deck()
|
||
notify("Loaded profile " .. profiles.active)
|
||
end
|
||
|
||
local function get_episode_number(filename)
|
||
-- Reverses the filename to start the search from the end as the media title might contain similar numbers.
|
||
local filename_reversed = filename:reverse()
|
||
|
||
local ep_num_patterns = {
|
||
"%s?(%d?%d?%d)[pP]?[eE]", -- Starting with E or EP (case-insensitive). "Example Series S01E01"
|
||
"%)(%d?%d?%d)%(", -- Surrounded by parentheses. "Example Series (12)"
|
||
"%](%d?%d?%d)%[", -- Surrounded by brackets. "Example Series [01]"
|
||
"%s(%d?%d?%d)%s", -- Surrounded by whitespace. "Example Series 124 [1080p 10-bit]"
|
||
"_(%d?%d?%d)_", -- Surrounded by underscores. "Example_Series_04_1080p"
|
||
"^(%d?%d?%d)[%s_]", -- Ending to the episode number. "Example Series 124"
|
||
"(%d?%d?%d)%-edosipE", -- Prepended by "Episode-". "Example Episode-165"
|
||
}
|
||
|
||
local s, e, episode_num
|
||
for _, pattern in pairs(ep_num_patterns) do
|
||
s, e, episode_num = string.find(filename_reversed, pattern)
|
||
if not is_empty(episode_num) then
|
||
return #filename - e, #filename - s, episode_num:reverse()
|
||
end
|
||
end
|
||
end
|
||
|
||
local function tag_format(filename)
|
||
filename = remove_extension(filename)
|
||
filename = remove_common_resolutions(filename)
|
||
|
||
local s, e, episode_num = get_episode_number(filename)
|
||
|
||
if config.tag_del_episode_num == true and not is_empty(s) then
|
||
if config.tag_del_after_episode_num == true then
|
||
-- Removing everything (e.g. episode name) after the episode number including itself.
|
||
filename = filename:sub(1, s)
|
||
else
|
||
-- Removing the first found instance of the episode number.
|
||
filename = filename:sub(1, s) .. filename:sub(e + 1, -1)
|
||
end
|
||
end
|
||
|
||
if config.tag_nuke_brackets == true then
|
||
filename = remove_text_in_brackets(filename)
|
||
end
|
||
if config.tag_nuke_parentheses == true then
|
||
filename = remove_filename_text_in_parentheses(filename)
|
||
end
|
||
|
||
if config.tag_filename_lowercase == true then
|
||
filename = filename:lower()
|
||
end
|
||
|
||
filename = remove_leading_trailing_spaces(filename)
|
||
filename = filename:gsub(" ", "_")
|
||
filename = filename:gsub("_%-_", "_") -- Replaces garbage _-_ substrings with a underscore
|
||
filename = remove_leading_trailing_dashes(filename)
|
||
return filename, episode_num or ''
|
||
end
|
||
|
||
local function substitute_fmt(tag)
|
||
local filename, episode = tag_format(mp.get_property("filename"))
|
||
|
||
local function substitute_filename(_tag)
|
||
return _tag:gsub("%%n", filename)
|
||
end
|
||
|
||
local function substitute_episode_number(_tag)
|
||
return _tag:gsub("%%d", episode)
|
||
end
|
||
|
||
local function substitute_time_pos(_tag)
|
||
local time_pos = human_readable_time(mp.get_property_number('time-pos'))
|
||
return _tag:gsub("%%t", time_pos)
|
||
end
|
||
|
||
local function substitute_envvar(_tag)
|
||
local env_tags = os.getenv('SUBS2SRS_TAGS') or ''
|
||
return _tag:gsub("%%e", env_tags)
|
||
end
|
||
|
||
tag = substitute_filename(tag)
|
||
tag = substitute_episode_number(tag)
|
||
tag = substitute_time_pos(tag)
|
||
tag = substitute_envvar(tag)
|
||
tag = remove_leading_trailing_spaces(tag)
|
||
|
||
return tag
|
||
end
|
||
|
||
local function construct_note_fields(sub_text, snapshot_filename, audio_filename)
|
||
local ret = {
|
||
[config.sentence_field] = sub_text,
|
||
[config.image_field] = string.format('<img alt="snapshot" src="%s">', snapshot_filename),
|
||
[config.audio_field] = string.format('[sound:%s]', audio_filename),
|
||
}
|
||
if config.miscinfo_enable == true then
|
||
ret[config.miscinfo_field] = substitute_fmt(config.miscinfo_format)
|
||
end
|
||
return ret
|
||
end
|
||
|
||
local function minutes_ago(m)
|
||
return (os.time() - 60 * m) * 1000
|
||
end
|
||
|
||
local function join_media_fields(new_data, stored_data)
|
||
for _, field in pairs { config.audio_field, config.image_field, config.miscinfo_field } do
|
||
new_data[field] = table.get(stored_data, field, "") .. table.get(new_data, field, "")
|
||
end
|
||
return new_data
|
||
end
|
||
|
||
local function update_sentence(new_data, stored_data)
|
||
-- adds support for TSCs
|
||
-- https://tatsumoto-ren.github.io/blog/discussing-various-card-templates.html#targeted-sentence-cards-or-mpvacious-cards
|
||
-- if the target word was marked by yomichan, this function makes sure that the highlighting doesn't get erased.
|
||
|
||
if is_empty(stored_data[config.sentence_field]) then
|
||
-- sentence field is empty. can't continue.
|
||
return new_data
|
||
elseif is_empty(new_data[config.sentence_field]) then
|
||
-- *new* sentence field is empty, but old one contains data. don't delete the existing sentence.
|
||
new_data[config.sentence_field] = stored_data[config.sentence_field]
|
||
return new_data
|
||
end
|
||
|
||
local _, opentag, target, closetag, _ = stored_data[config.sentence_field]:match('^(.-)(<[^>]+>)(.-)(</[^>]+>)(.-)$')
|
||
if target then
|
||
local prefix, _, suffix = new_data[config.sentence_field]:match(table.concat { '^(.-)(', target, ')(.-)$' })
|
||
if prefix and suffix then
|
||
new_data[config.sentence_field] = table.concat { prefix, opentag, target, closetag, suffix }
|
||
end
|
||
end
|
||
return new_data
|
||
end
|
||
|
||
local function audio_padding()
|
||
local video_duration = mp.get_property_number('duration')
|
||
if config.audio_padding == 0.0 or not video_duration then
|
||
return 0.0
|
||
end
|
||
if subs.user_timings.is_set('start') or subs.user_timings.is_set('end') then
|
||
return 0.0
|
||
end
|
||
return config.audio_padding
|
||
end
|
||
|
||
------------------------------------------------------------
|
||
-- utility classes
|
||
|
||
local function new_timings()
|
||
local self = { ['start'] = -1, ['end'] = -1, }
|
||
local is_set = function(position)
|
||
return self[position] >= 0
|
||
end
|
||
local set = function(position)
|
||
self[position] = mp.get_property_number('time-pos')
|
||
end
|
||
local get = function(position)
|
||
return self[position]
|
||
end
|
||
return {
|
||
is_set = is_set,
|
||
set = set,
|
||
get = get,
|
||
}
|
||
end
|
||
|
||
local function new_sub_list()
|
||
local subs_list = {}
|
||
local _is_empty = function()
|
||
return next(subs_list) == nil
|
||
end
|
||
local find_i = function(sub)
|
||
for i, v in ipairs(subs_list) do
|
||
if sub < v then
|
||
return i
|
||
end
|
||
end
|
||
return #subs_list + 1
|
||
end
|
||
local get_time = function(position)
|
||
local i = position == 'start' and 1 or #subs_list
|
||
return subs_list[i][position]
|
||
end
|
||
local get_text = function()
|
||
local speech = {}
|
||
for _, sub in ipairs(subs_list) do
|
||
table.insert(speech, sub['text'])
|
||
end
|
||
return table.concat(speech, ' ')
|
||
end
|
||
local insert = function(sub)
|
||
if sub ~= nil and not table.contains(subs_list, sub) then
|
||
table.insert(subs_list, find_i(sub), sub)
|
||
return true
|
||
end
|
||
return false
|
||
end
|
||
return {
|
||
get_time = get_time,
|
||
get_text = get_text,
|
||
is_empty = _is_empty,
|
||
insert = insert
|
||
}
|
||
end
|
||
|
||
local function make_switch(states)
|
||
local self = {
|
||
states = states,
|
||
current_state = 1
|
||
}
|
||
local bump = function()
|
||
self.current_state = self.current_state + 1
|
||
if self.current_state > #self.states then
|
||
self.current_state = 1
|
||
end
|
||
end
|
||
local get = function()
|
||
return self.states[self.current_state]
|
||
end
|
||
return {
|
||
bump = bump,
|
||
get = get
|
||
}
|
||
end
|
||
|
||
local filename_factory = (function()
|
||
local filename
|
||
|
||
local anki_compatible_length = (function()
|
||
-- Anki forcibly mutilates all filenames longer than 119 bytes when you run `Tools->Check Media...`.
|
||
local allowed_bytes = 119
|
||
local timestamp_bytes = #'_99h99m99s999ms-99h99m99s999ms.webp'
|
||
|
||
return function(str, timestamp)
|
||
-- if timestamp provided, recalculate limit_bytes
|
||
local limit_bytes = allowed_bytes - (timestamp and #timestamp or timestamp_bytes)
|
||
|
||
if #str <= limit_bytes then
|
||
return str
|
||
end
|
||
|
||
local bytes_per_char = contains_non_latin_letters(str) and #'車' or #'z'
|
||
local limit_chars = math.floor(limit_bytes / bytes_per_char)
|
||
|
||
if limit_chars == limit_bytes then
|
||
return str:sub(1, limit_bytes)
|
||
end
|
||
|
||
local ret = subprocess {
|
||
'awk',
|
||
'-v', string.format('str=%s', str),
|
||
'-v', string.format('limit=%d', limit_chars),
|
||
'BEGIN{print substr(str, 1, limit); exit}'
|
||
}
|
||
|
||
if ret.status == 0 then
|
||
ret.stdout = remove_newlines(ret.stdout)
|
||
ret.stdout = remove_leading_trailing_spaces(ret.stdout)
|
||
return ret.stdout
|
||
else
|
||
return 'subs2srs_' .. os.time()
|
||
end
|
||
end
|
||
end)()
|
||
|
||
local make_media_filename = function()
|
||
filename = mp.get_property("filename") -- filename without path
|
||
filename = remove_extension(filename)
|
||
filename = remove_text_in_brackets(filename)
|
||
filename = remove_special_characters(filename)
|
||
end
|
||
|
||
local make_audio_filename = function(speech_start, speech_end)
|
||
local filename_timestamp = string.format(
|
||
'_%s-%s%s',
|
||
human_readable_time(speech_start),
|
||
human_readable_time(speech_end),
|
||
config.audio_extension
|
||
)
|
||
return anki_compatible_length(filename, filename_timestamp) .. filename_timestamp
|
||
end
|
||
|
||
local make_snapshot_filename = function(timestamp)
|
||
local filename_timestamp = string.format(
|
||
'_%s%s',
|
||
human_readable_time(timestamp),
|
||
config.snapshot_extension
|
||
)
|
||
return anki_compatible_length(filename, filename_timestamp) .. filename_timestamp
|
||
end
|
||
|
||
mp.register_event("file-loaded", make_media_filename)
|
||
|
||
return {
|
||
make_audio_filename = make_audio_filename,
|
||
make_snapshot_filename = make_snapshot_filename,
|
||
}
|
||
end)()
|
||
|
||
------------------------------------------------------------
|
||
-- front for adding and updating notes
|
||
|
||
local function export_to_anki(gui)
|
||
local sub = subs.get()
|
||
if sub == nil then
|
||
notify("Nothing to export.", "warn", 1)
|
||
return
|
||
end
|
||
|
||
if not gui and is_empty(sub['text']) then
|
||
sub['text'] = string.format("mpvacious wasn't able to grab subtitles (%s)", os.time())
|
||
end
|
||
|
||
local snapshot_timestamp = mp.get_property_number("time-pos", 0)
|
||
local snapshot_filename = filename_factory.make_snapshot_filename(snapshot_timestamp)
|
||
local audio_filename = filename_factory.make_audio_filename(sub['start'], sub['end'])
|
||
|
||
encoder.create_snapshot(snapshot_timestamp, snapshot_filename)
|
||
encoder.create_audio(sub['start'], sub['end'], audio_filename, audio_padding())
|
||
|
||
local note_fields = construct_note_fields(sub['text'], snapshot_filename, audio_filename)
|
||
subs.clear()
|
||
end
|
||
|
||
local function update_last_note(overwrite)
|
||
return
|
||
end
|
||
|
||
------------------------------------------------------------
|
||
-- seeking: sub replay, sub seek, sub rewind
|
||
|
||
local function _(params)
|
||
return function()
|
||
return pcall(unpack(params))
|
||
end
|
||
end
|
||
|
||
local pause_timer = (function()
|
||
local stop_time = -1
|
||
local check_stop
|
||
local set_stop_time = function(time)
|
||
stop_time = time
|
||
mp.observe_property("time-pos", "number", check_stop)
|
||
end
|
||
local stop = function()
|
||
mp.unobserve_property(check_stop)
|
||
stop_time = -1
|
||
end
|
||
check_stop = function(_, time)
|
||
if time > stop_time then
|
||
stop()
|
||
mp.set_property("pause", "yes")
|
||
end
|
||
end
|
||
return {
|
||
set_stop_time = set_stop_time,
|
||
check_stop = check_stop,
|
||
stop = stop,
|
||
}
|
||
end)()
|
||
|
||
local play_control = (function()
|
||
local current_sub
|
||
|
||
local function stop_at_the_end(sub)
|
||
pause_timer.set_stop_time(sub['end'] - 0.050)
|
||
notify("Playing till the end of the sub...", "info", 3)
|
||
end
|
||
|
||
local function play_till_sub_end()
|
||
local sub = subs.get_current()
|
||
mp.commandv('seek', sub['start'], 'absolute')
|
||
mp.set_property("pause", "no")
|
||
stop_at_the_end(sub)
|
||
end
|
||
|
||
local function sub_seek(direction, pause)
|
||
mp.commandv("sub_seek", direction == 'backward' and '-1' or '1')
|
||
mp.commandv("seek", "0.015", "relative+exact")
|
||
if pause then
|
||
mp.set_property("pause", "yes")
|
||
end
|
||
pause_timer.stop()
|
||
end
|
||
|
||
local function sub_rewind()
|
||
mp.commandv('seek', subs.get_current()['start'] + 0.015, 'absolute')
|
||
pause_timer.stop()
|
||
end
|
||
|
||
local function check_sub()
|
||
local sub = subs.get_current()
|
||
if sub and sub ~= current_sub then
|
||
mp.unobserve_property(check_sub)
|
||
stop_at_the_end(sub)
|
||
end
|
||
end
|
||
|
||
local function play_till_next_sub_end()
|
||
current_sub = subs.get_current()
|
||
mp.observe_property("sub-text", "string", check_sub)
|
||
mp.set_property("pause", "no")
|
||
notify("Waiting till next sub...", "info", 10)
|
||
end
|
||
|
||
return {
|
||
play_till_sub_end = play_till_sub_end,
|
||
play_till_next_sub_end = play_till_next_sub_end,
|
||
sub_seek = sub_seek,
|
||
sub_rewind = sub_rewind,
|
||
}
|
||
end)()
|
||
|
||
------------------------------------------------------------
|
||
-- platform specific
|
||
|
||
local function init_platform_windows()
|
||
local self = {}
|
||
local curl_tmpfile_path = utils.join_path(os.getenv('TEMP'), 'curl_tmp.txt')
|
||
mp.register_event('shutdown', function()
|
||
os.remove(curl_tmpfile_path)
|
||
end)
|
||
|
||
self.tmp_dir = function()
|
||
return os.getenv('TEMP')
|
||
end
|
||
|
||
self.copy_to_clipboard = function(text)
|
||
text = text:gsub("&", "^^^&"):gsub("[<>|]", "")
|
||
mp.commandv("run", "cmd.exe", "/d", "/c", string.format("@echo off & chcp 65001 >nul & echo %s|clip", text))
|
||
end
|
||
|
||
self.curl_request = function(request_json, completion_fn)
|
||
end
|
||
|
||
self.windows = true
|
||
|
||
return self
|
||
end
|
||
|
||
local function init_platform_nix()
|
||
local self = {}
|
||
local clip = is_running_macOS() and 'LANG=en_US.UTF-8 pbcopy' or is_running_wayland() and 'wl-copy' or 'xclip -i -selection clipboard'
|
||
|
||
self.tmp_dir = function()
|
||
return '/tmp'
|
||
end
|
||
|
||
self.copy_to_clipboard = function(text)
|
||
local handle = io.popen(clip, 'w')
|
||
handle:write(text)
|
||
handle:close()
|
||
end
|
||
|
||
self.curl_request = function(request_json, completion_fn)
|
||
end
|
||
|
||
return self
|
||
end
|
||
|
||
platform = is_running_windows() and init_platform_windows() or init_platform_nix()
|
||
|
||
------------------------------------------------------------
|
||
-- utils for downloading pronunciations from Forvo
|
||
|
||
do
|
||
local base64d -- http://lua-users.org/wiki/BaseSixtyFour
|
||
do
|
||
local b = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
|
||
base64d = function(data)
|
||
data = string.gsub(data, '[^'..b..'=]', '')
|
||
return (data:gsub('.', function(x)
|
||
if (x == '=') then return '' end
|
||
local r,f='',(b:find(x)-1)
|
||
for i=6,1,-1 do r=r..(f%2^i-f%2^(i-1)>0 and '1' or '0') end
|
||
return r;
|
||
end):gsub('%d%d%d?%d?%d?%d?%d?%d?', function(x)
|
||
if (#x ~= 8) then return '' end
|
||
local c=0
|
||
for i=1,8 do c=c+(x:sub(i,i)=='1' and 2^(8-i) or 0) end
|
||
return string.char(c)
|
||
end))
|
||
end
|
||
end
|
||
|
||
local function url_encode(url)
|
||
-- https://gist.github.com/liukun/f9ce7d6d14fa45fe9b924a3eed5c3d99
|
||
local char_to_hex = function(c)
|
||
return string.format("%%%02X", string.byte(c))
|
||
end
|
||
if url == nil then
|
||
return
|
||
end
|
||
url = url:gsub("\n", "\r\n")
|
||
url = url:gsub("([^%w _%%%-%.~])", char_to_hex)
|
||
url = url:gsub(" ", "+")
|
||
return url
|
||
end
|
||
|
||
local function reencode(source_path, dest_path)
|
||
end
|
||
|
||
local function reencode_and_store(source_path, filename)
|
||
local reencoded_path = utils.join_path(platform.tmp_dir(), 'reencoded_' .. filename)
|
||
reencode(source_path, reencoded_path)
|
||
local result = ankiconnect.store_file(filename, reencoded_path)
|
||
os.remove(reencoded_path)
|
||
return result
|
||
end
|
||
|
||
local function curl_save(source_url, save_location)
|
||
return true
|
||
end
|
||
|
||
local function get_pronunciation_url(word)
|
||
end
|
||
|
||
local function make_forvo_filename(word)
|
||
return string.format('forvo_%s%s', platform.windows and os.time() or word, config.audio_extension)
|
||
end
|
||
|
||
local function get_forvo_pronunciation(word)
|
||
local audio_url = get_pronunciation_url(word)
|
||
|
||
if is_empty(audio_url) then
|
||
msg.warn(string.format("Seems like Forvo doesn't have audio for word %s.", word))
|
||
return
|
||
end
|
||
|
||
local filename = make_forvo_filename(word)
|
||
local tmp_filepath = utils.join_path(platform.tmp_dir(), filename)
|
||
|
||
local result
|
||
if curl_save(audio_url, tmp_filepath) and reencode_and_store(tmp_filepath, filename) then
|
||
result = string.format('[sound:%s]', filename)
|
||
else
|
||
msg.warn(string.format("Couldn't download audio for word %s from Forvo.", word))
|
||
end
|
||
|
||
os.remove(tmp_filepath)
|
||
return result
|
||
end
|
||
|
||
append_forvo_pronunciation = function(new_data, stored_data)
|
||
if config.use_forvo == 'no' then
|
||
-- forvo functionality was disabled in the config file
|
||
return new_data
|
||
end
|
||
|
||
if type(stored_data[config.vocab_audio_field]) ~= 'string' then
|
||
-- there is no field configured to store forvo pronunciation
|
||
return new_data
|
||
end
|
||
|
||
if is_empty(stored_data[config.vocab_field]) then
|
||
-- target word field is empty. can't continue.
|
||
return new_data
|
||
end
|
||
|
||
if config.use_forvo == 'always' or is_empty(stored_data[config.vocab_audio_field]) then
|
||
local forvo_pronunciation = get_forvo_pronunciation(stored_data[config.vocab_field])
|
||
if not is_empty(forvo_pronunciation) then
|
||
if config.vocab_audio_field == config.audio_field then
|
||
-- improperly configured fields. don't lose sentence audio
|
||
new_data[config.audio_field] = forvo_pronunciation .. new_data[config.audio_field]
|
||
else
|
||
new_data[config.vocab_audio_field] = forvo_pronunciation
|
||
end
|
||
end
|
||
end
|
||
|
||
return new_data
|
||
end
|
||
end
|
||
|
||
------------------------------------------------------------
|
||
-- AnkiConnect requests
|
||
|
||
ankiconnect = {}
|
||
|
||
ankiconnect.execute = function(request, completion_fn)
|
||
-- utils.format_json returns a string
|
||
-- On error, request_json will contain "null", not nil.
|
||
local request_json, error = utils.format_json(request)
|
||
|
||
if error ~= nil or request_json == "null" then
|
||
return completion_fn and completion_fn()
|
||
else
|
||
return platform.curl_request(request_json, completion_fn)
|
||
end
|
||
end
|
||
|
||
ankiconnect.parse_result = function(curl_output)
|
||
return
|
||
end
|
||
|
||
ankiconnect.store_file = function(filename, file_path)
|
||
return true
|
||
end
|
||
|
||
ankiconnect.create_deck = function(deck_name)
|
||
local args = {
|
||
action = "changeDeck",
|
||
version = 6,
|
||
params = {
|
||
cards = {},
|
||
deck = deck_name
|
||
}
|
||
}
|
||
local result_notify = function(_, result, _)
|
||
return
|
||
end
|
||
ankiconnect.execute(args, result_notify)
|
||
end
|
||
|
||
ankiconnect.add_note = function(note_fields, gui)
|
||
local action = gui and 'guiAddCards' or 'addNote'
|
||
local tags = is_empty(config.note_tag) and {} or { substitute_fmt(config.note_tag) }
|
||
local args = {
|
||
action = action,
|
||
version = 6,
|
||
params = {
|
||
note = {
|
||
deckName = config.deck_name,
|
||
modelName = config.model_name,
|
||
fields = note_fields,
|
||
options = {
|
||
allowDuplicate = config.allow_duplicates,
|
||
duplicateScope = "deck",
|
||
},
|
||
tags = tags,
|
||
}
|
||
}
|
||
}
|
||
end
|
||
|
||
ankiconnect.get_last_note_id = function()
|
||
local ret = ankiconnect.execute {
|
||
action = "findNotes",
|
||
version = 6,
|
||
params = {
|
||
query = "added:1" -- find all notes added today
|
||
}
|
||
}
|
||
|
||
end
|
||
|
||
ankiconnect.get_note_fields = function(note_id)
|
||
local ret = ankiconnect.execute {
|
||
action = "notesInfo",
|
||
version = 6,
|
||
params = {
|
||
notes = { note_id }
|
||
}
|
||
}
|
||
|
||
end
|
||
|
||
ankiconnect.gui_browse = function(query)
|
||
ankiconnect.execute {
|
||
action = 'guiBrowse',
|
||
version = 6,
|
||
params = {
|
||
query = query
|
||
}
|
||
}
|
||
end
|
||
|
||
ankiconnect.add_tag = function(note_id, tag)
|
||
if not is_empty(tag) then
|
||
tag = substitute_fmt(tag)
|
||
ankiconnect.execute {
|
||
action = 'addTags',
|
||
version = 6,
|
||
params = {
|
||
notes = { note_id },
|
||
tags = tag
|
||
}
|
||
}
|
||
end
|
||
end
|
||
|
||
ankiconnect.append_media = function(note_id, fields, create_media_fn)
|
||
-- AnkiConnect will fail to update the note if it's selected in the Anki Browser.
|
||
-- https://github.com/FooSoft/anki-connect/issues/82
|
||
-- Switch focus from the current note to avoid it.
|
||
ankiconnect.gui_browse("nid:1") -- impossible nid
|
||
|
||
local args = {
|
||
action = "updateNoteFields",
|
||
version = 6,
|
||
params = {
|
||
note = {
|
||
id = note_id,
|
||
fields = fields,
|
||
}
|
||
}
|
||
}
|
||
|
||
local on_finish = function(_, result, _)
|
||
return
|
||
end
|
||
|
||
ankiconnect.execute(args, on_finish)
|
||
end
|
||
|
||
------------------------------------------------------------
|
||
-- subtitles and timings
|
||
|
||
subs = {
|
||
dialogs = new_sub_list(),
|
||
user_timings = new_timings(),
|
||
observed = false
|
||
}
|
||
|
||
subs.get_current = function()
|
||
return Subtitle:now()
|
||
end
|
||
|
||
subs.get_timing = function(position)
|
||
if subs.user_timings.is_set(position) then
|
||
return subs.user_timings.get(position)
|
||
elseif not subs.dialogs.is_empty() then
|
||
return subs.dialogs.get_time(position)
|
||
end
|
||
return -1
|
||
end
|
||
|
||
subs.get = function()
|
||
if subs.dialogs.is_empty() then
|
||
subs.dialogs.insert(subs.get_current())
|
||
end
|
||
local sub = Subtitle:new {
|
||
['text'] = subs.dialogs.get_text(),
|
||
['start'] = subs.get_timing('start'),
|
||
['end'] = subs.get_timing('end'),
|
||
}
|
||
if sub['start'] < 0 or sub['end'] < 0 then
|
||
return nil
|
||
end
|
||
if sub['start'] == sub['end'] then
|
||
return nil
|
||
end
|
||
if sub['start'] > sub['end'] then
|
||
sub['start'], sub['end'] = sub['end'], sub['start']
|
||
end
|
||
if not is_empty(sub['text']) then
|
||
sub['text'] = trim(sub['text'])
|
||
sub['text'] = escape_special_characters(sub['text'])
|
||
end
|
||
return sub
|
||
end
|
||
|
||
subs.append = function()
|
||
if subs.dialogs.insert(subs.get_current()) then
|
||
menu.update()
|
||
end
|
||
end
|
||
|
||
subs.observe = function()
|
||
mp.observe_property("sub-text", "string", subs.append)
|
||
subs.observed = true
|
||
end
|
||
|
||
subs.unobserve = function()
|
||
mp.unobserve_property(subs.append)
|
||
subs.observed = false
|
||
end
|
||
|
||
subs.set_timing = function(position)
|
||
subs.user_timings.set(position)
|
||
notify(capitalize_first_letter(position) .. " time has been set.")
|
||
if not subs.observed then
|
||
subs.observe()
|
||
end
|
||
end
|
||
|
||
subs.set_starting_line = function()
|
||
subs.clear()
|
||
if subs.get_current() then
|
||
subs.observe()
|
||
notify("Timings have been set to the current sub.", "info", 2)
|
||
else
|
||
notify("There's no visible subtitle.", "info", 2)
|
||
end
|
||
end
|
||
|
||
subs.clear = function()
|
||
subs.unobserve()
|
||
subs.dialogs = new_sub_list()
|
||
subs.user_timings = new_timings()
|
||
end
|
||
|
||
subs.clear_and_notify = function()
|
||
subs.clear()
|
||
notify("Timings have been reset.", "info", 2)
|
||
end
|
||
|
||
------------------------------------------------------------
|
||
-- send subs to clipboard as they appear
|
||
|
||
clip_autocopy = (function()
|
||
local enable = function()
|
||
mp.observe_property("sub-text", "string", copy_to_clipboard)
|
||
end
|
||
|
||
local disable = function()
|
||
mp.unobserve_property(copy_to_clipboard)
|
||
end
|
||
|
||
local state_notify = function()
|
||
notify(string.format("Clipboard autocopy has been %s.", config.autoclip and 'enabled' or 'disabled'))
|
||
end
|
||
|
||
local toggle = function()
|
||
config.autoclip = not config.autoclip
|
||
if config.autoclip == true then
|
||
enable()
|
||
else
|
||
disable()
|
||
end
|
||
state_notify()
|
||
end
|
||
|
||
local is_enabled = function()
|
||
return config.autoclip == true and 'enabled' or 'disabled'
|
||
end
|
||
|
||
local init = function()
|
||
if config.autoclip == true then
|
||
enable()
|
||
end
|
||
end
|
||
|
||
return {
|
||
enable = enable,
|
||
disable = disable,
|
||
init = init,
|
||
toggle = toggle,
|
||
is_enabled = is_enabled,
|
||
}
|
||
end)()
|
||
|
||
------------------------------------------------------------
|
||
-- Subtitle class provides methods for comparing subtitle lines
|
||
|
||
Subtitle = {
|
||
['text'] = '',
|
||
['start'] = -1,
|
||
['end'] = -1,
|
||
}
|
||
|
||
function Subtitle:new(o)
|
||
o = o or {}
|
||
setmetatable(o, self)
|
||
self.__index = self
|
||
return o
|
||
end
|
||
|
||
function Subtitle:now()
|
||
local delay = mp.get_property_native("sub-delay") - mp.get_property_native("audio-delay")
|
||
local text = mp.get_property("sub-text")
|
||
local this = self:new {
|
||
['text'] = not is_empty(text) and text or "<PGS subtitles>",
|
||
['start'] = mp.get_property_number("sub-start"),
|
||
['end'] = mp.get_property_number("sub-end"),
|
||
}
|
||
return this:valid() and this:delay(delay) or nil
|
||
end
|
||
|
||
function Subtitle:delay(delay)
|
||
self['start'] = self['start'] + delay
|
||
self['end'] = self['end'] + delay
|
||
return self
|
||
end
|
||
|
||
function Subtitle:valid()
|
||
return not is_empty(self['text']) and self['start'] and self['end'] and self['start'] >= 0 and self['end'] > 0
|
||
end
|
||
|
||
Subtitle.__eq = function(lhs, rhs)
|
||
return lhs['text'] == rhs['text']
|
||
end
|
||
|
||
Subtitle.__lt = function(lhs, rhs)
|
||
return lhs['start'] < rhs['start']
|
||
end
|
||
|
||
------------------------------------------------------------
|
||
-- main menu
|
||
|
||
menu = {
|
||
active = false,
|
||
hints_state = make_switch { 'hidden', 'menu', 'global', },
|
||
overlay = nil;
|
||
}
|
||
|
||
menu.overlay_draw = function(text)
|
||
menu.overlay.data = text
|
||
menu.overlay:update()
|
||
end
|
||
|
||
menu.with_update = function(params)
|
||
return function()
|
||
pcall(unpack(params))
|
||
menu.update()
|
||
end
|
||
end
|
||
|
||
menu.keybindings = {
|
||
{ key = 's', fn = menu.with_update { subs.set_timing, 'start' } },
|
||
{ key = 'e', fn = menu.with_update { subs.set_timing, 'end' } },
|
||
{ key = 'c', fn = menu.with_update { subs.set_starting_line } },
|
||
{ key = 'r', fn = menu.with_update { subs.clear_and_notify } },
|
||
{ key = 'g', fn = menu.with_update { export_to_anki, true } },
|
||
{ key = 'n', fn = menu.with_update { export_to_anki, false } },
|
||
{ key = 'm', fn = menu.with_update { update_last_note, false } },
|
||
{ key = 'M', fn = menu.with_update { update_last_note, true } },
|
||
{ key = 't', fn = menu.with_update { clip_autocopy.toggle } },
|
||
{ key = 'i', fn = menu.with_update { menu.hints_state.bump } },
|
||
{ key = 'p', fn = menu.with_update { load_next_profile } },
|
||
{ key = 'ESC', fn = function() menu.close() end },
|
||
}
|
||
|
||
menu.update = function()
|
||
return
|
||
end
|
||
|
||
menu.open = function()
|
||
if menu.overlay == nil then
|
||
notify("OSD overlay is not supported in " .. mp.get_property("mpv-version"), "error", 5)
|
||
return
|
||
end
|
||
|
||
if menu.active == true then
|
||
menu.close()
|
||
return
|
||
end
|
||
|
||
for _, val in pairs(menu.keybindings) do
|
||
mp.add_forced_key_binding(val.key, val.key, val.fn)
|
||
end
|
||
|
||
menu.active = true
|
||
menu.update()
|
||
end
|
||
|
||
menu.close = function()
|
||
if menu.active == false then
|
||
return
|
||
end
|
||
|
||
for _, val in pairs(menu.keybindings) do
|
||
mp.remove_key_binding(val.key)
|
||
end
|
||
|
||
menu.overlay:remove()
|
||
menu.active = false
|
||
end
|
||
|
||
------------------------------------------------------------
|
||
-- main
|
||
|
||
local main = (function()
|
||
local main_executed = false
|
||
return function()
|
||
if main_executed then
|
||
return
|
||
else
|
||
main_executed = true
|
||
end
|
||
|
||
config_manager.init(config, profiles)
|
||
encoder.init(config, ankiconnect.store_file, platform.tmp_dir, subprocess)
|
||
clip_autocopy.init()
|
||
ensure_deck()
|
||
|
||
-- Key bindings
|
||
mp.add_forced_key_binding("Ctrl+n", "mpvacious-export-note", export_to_anki)
|
||
mp.add_forced_key_binding("Ctrl+c", "mpvacious-copy-sub-to-clipboard", copy_sub_to_clipboard)
|
||
mp.add_key_binding("Ctrl+t", "mpvacious-autocopy-toggle", clip_autocopy.toggle)
|
||
|
||
-- Open advanced menu
|
||
mp.add_key_binding("a", "mpvacious-menu-open", menu.open)
|
||
|
||
-- Note updating
|
||
mp.add_key_binding("Ctrl+m", "mpvacious-update-last-note", _ { update_last_note, false })
|
||
mp.add_key_binding("Ctrl+M", "mpvacious-overwrite-last-note", _ { update_last_note, true })
|
||
|
||
-- Vim-like seeking between subtitle lines
|
||
mp.add_key_binding("H", "mpvacious-sub-seek-back", _ { play_control.sub_seek, 'backward' })
|
||
mp.add_key_binding("L", "mpvacious-sub-seek-forward", _ { play_control.sub_seek, 'forward' })
|
||
|
||
mp.add_key_binding("Alt+h", "mpvacious-sub-seek-back-pause", _ { play_control.sub_seek, 'backward', true })
|
||
mp.add_key_binding("Alt+l", "mpvacious-sub-seek-forward-pause", _ { play_control.sub_seek, 'forward', true })
|
||
|
||
mp.add_key_binding("Ctrl+h", "mpvacious-sub-rewind", _ { play_control.sub_rewind })
|
||
mp.add_key_binding("Ctrl+H", "mpvacious-sub-replay", _ { play_control.play_till_sub_end })
|
||
mp.add_key_binding("Ctrl+L", "mpvacious-sub-play-up-to-next", _ { play_control.play_till_next_sub_end })
|
||
end
|
||
end)()
|
||
|
||
mp.register_event("file-loaded", main)
|