2014-11-19 17:37:23 +00:00
|
|
|
local utils = require 'mp.utils'
|
|
|
|
local msg = require 'mp.msg'
|
|
|
|
|
|
|
|
local ytdl = {
|
2015-10-10 22:35:35 +00:00
|
|
|
path = "youtube-dl",
|
|
|
|
searched = false
|
2014-11-19 17:37:23 +00:00
|
|
|
}
|
|
|
|
|
2016-09-27 21:23:10 +00:00
|
|
|
local chapter_list = {}
|
|
|
|
|
2015-01-24 19:54:35 +00:00
|
|
|
local function exec(args)
|
|
|
|
local ret = utils.subprocess({args = args})
|
2015-06-27 19:09:12 +00:00
|
|
|
return ret.status, ret.stdout, ret
|
2015-01-24 19:54:35 +00:00
|
|
|
end
|
|
|
|
|
2015-09-30 20:28:01 +00:00
|
|
|
-- return true if it was explicitly set on the command line
|
2015-01-24 19:54:35 +00:00
|
|
|
local function option_was_set(name)
|
2015-10-06 15:06:11 +00:00
|
|
|
return mp.get_property_bool("option-info/" ..name.. "/set-from-commandline",
|
2015-01-24 19:54:35 +00:00
|
|
|
false)
|
|
|
|
end
|
|
|
|
|
2017-06-09 07:08:54 +00:00
|
|
|
-- return true if the option was set locally
|
|
|
|
local function option_was_set_locally(name)
|
|
|
|
return mp.get_property_bool("option-info/" ..name.. "/set-locally", false)
|
|
|
|
end
|
|
|
|
|
2015-01-24 19:54:35 +00:00
|
|
|
-- youtube-dl may set special http headers for some sites (user-agent, cookies)
|
|
|
|
local function set_http_headers(http_headers)
|
|
|
|
if not http_headers then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
local headers = {}
|
|
|
|
local useragent = http_headers["User-Agent"]
|
|
|
|
if useragent and not option_was_set("user-agent") then
|
|
|
|
mp.set_property("file-local-options/user-agent", useragent)
|
|
|
|
end
|
2016-01-10 12:33:17 +00:00
|
|
|
local additional_fields = {"Cookie", "Referer"}
|
|
|
|
for idx, item in pairs(additional_fields) do
|
|
|
|
local field_value = http_headers[item]
|
|
|
|
if field_value then
|
|
|
|
headers[#headers + 1] = item .. ": " .. field_value
|
|
|
|
end
|
2014-11-19 17:37:23 +00:00
|
|
|
end
|
2015-01-24 19:54:35 +00:00
|
|
|
if #headers > 0 and not option_was_set("http-header-fields") then
|
|
|
|
mp.set_property_native("file-local-options/http-header-fields", headers)
|
|
|
|
end
|
|
|
|
end
|
2014-11-19 17:37:23 +00:00
|
|
|
|
2015-04-03 17:04:31 +00:00
|
|
|
local function append_rtmp_prop(props, name, value)
|
|
|
|
if not name or not value then
|
|
|
|
return props
|
|
|
|
end
|
|
|
|
|
|
|
|
if props and props ~= "" then
|
|
|
|
props = props..","
|
|
|
|
else
|
|
|
|
props = ""
|
|
|
|
end
|
|
|
|
|
|
|
|
return props..name.."=\""..value.."\""
|
|
|
|
end
|
|
|
|
|
2015-09-30 20:28:01 +00:00
|
|
|
local function edl_escape(url)
|
|
|
|
return "%" .. string.len(url) .. "%" .. url
|
|
|
|
end
|
|
|
|
|
2016-09-27 21:23:10 +00:00
|
|
|
local function time_to_secs(time_string)
|
|
|
|
local ret
|
|
|
|
|
|
|
|
local a, b, c = time_string:match("(%d+):(%d%d?):(%d%d)")
|
|
|
|
if a ~= nil then
|
|
|
|
ret = (a*3600 + b*60 + c)
|
|
|
|
else
|
|
|
|
a, b = time_string:match("(%d%d?):(%d%d)")
|
|
|
|
if a ~= nil then
|
|
|
|
ret = (a*60 + b)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
return ret
|
|
|
|
end
|
|
|
|
|
|
|
|
local function extract_chapters(data, video_length)
|
|
|
|
local ret = {}
|
|
|
|
|
|
|
|
for line in data:gmatch("[^\r\n]+") do
|
|
|
|
local time = time_to_secs(line)
|
|
|
|
if time and (time < video_length) then
|
|
|
|
table.insert(ret, {time = time, title = line})
|
|
|
|
end
|
|
|
|
end
|
2016-11-13 17:02:50 +00:00
|
|
|
table.sort(ret, function(a, b) return a.time < b.time end)
|
2016-09-27 21:23:10 +00:00
|
|
|
return ret
|
|
|
|
end
|
|
|
|
|
2017-02-10 19:43:32 +00:00
|
|
|
local function edl_track_joined(fragments, protocol, is_live)
|
2017-02-06 16:08:18 +00:00
|
|
|
if not (type(fragments) == "table") or not fragments[1] then
|
|
|
|
msg.debug("No fragments to join into EDL")
|
|
|
|
return nil
|
|
|
|
end
|
|
|
|
|
2017-01-30 15:57:28 +00:00
|
|
|
local edl = "edl://"
|
2017-01-30 18:38:43 +00:00
|
|
|
local offset = 1
|
2017-05-04 16:10:07 +00:00
|
|
|
local parts = {}
|
2017-02-06 16:08:18 +00:00
|
|
|
|
|
|
|
if (protocol == "http_dash_segments") and
|
2017-02-10 19:43:32 +00:00
|
|
|
not fragments[1].duration and not is_live then
|
2017-02-06 16:08:18 +00:00
|
|
|
-- assume MP4 DASH initialization segment
|
2017-05-04 16:10:07 +00:00
|
|
|
table.insert(parts,
|
|
|
|
"!mp4_dash,init=" .. edl_escape(fragments[1].url))
|
2017-01-30 18:38:43 +00:00
|
|
|
offset = 2
|
2017-02-06 16:08:18 +00:00
|
|
|
|
|
|
|
-- Check remaining fragments for duration;
|
|
|
|
-- if not available in all, give up.
|
|
|
|
for i = offset, #fragments do
|
|
|
|
if not fragments[i].duration then
|
|
|
|
msg.error("EDL doesn't support fragments" ..
|
|
|
|
"without duration with MP4 DASH")
|
|
|
|
return nil
|
|
|
|
end
|
|
|
|
end
|
2017-01-30 18:38:43 +00:00
|
|
|
end
|
2017-02-06 16:08:18 +00:00
|
|
|
|
2017-01-30 18:38:43 +00:00
|
|
|
for i = offset, #fragments do
|
2017-01-30 15:57:28 +00:00
|
|
|
local fragment = fragments[i]
|
2017-05-04 16:10:07 +00:00
|
|
|
table.insert(parts, edl_escape(fragment.url))
|
2017-01-30 15:57:28 +00:00
|
|
|
if fragment.duration then
|
2017-05-04 16:10:07 +00:00
|
|
|
parts[#parts] =
|
|
|
|
parts[#parts] .. ",length="..fragment.duration
|
2017-01-30 15:57:28 +00:00
|
|
|
end
|
|
|
|
end
|
2017-05-04 16:10:07 +00:00
|
|
|
return edl .. table.concat(parts, ";") .. ";"
|
2017-01-30 15:57:28 +00:00
|
|
|
end
|
2015-09-30 20:28:01 +00:00
|
|
|
|
2017-04-22 20:47:34 +00:00
|
|
|
local function add_single_video(json)
|
|
|
|
local streamurl = ""
|
|
|
|
|
|
|
|
-- DASH/split tracks
|
|
|
|
if not (json["requested_formats"] == nil) then
|
|
|
|
for _, track in pairs(json.requested_formats) do
|
|
|
|
local edl_track = nil
|
|
|
|
edl_track = edl_track_joined(track.fragments,
|
|
|
|
track.protocol, json.is_live)
|
|
|
|
if track.acodec and track.acodec ~= "none" then
|
|
|
|
-- audio track
|
|
|
|
mp.commandv("audio-add",
|
|
|
|
edl_track or track.url, "auto",
|
|
|
|
track.format_note or "")
|
|
|
|
elseif track.vcodec and track.vcodec ~= "none" then
|
|
|
|
-- video track
|
|
|
|
streamurl = edl_track or track.url
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
elseif not (json.url == nil) then
|
|
|
|
local edl_track = nil
|
|
|
|
edl_track = edl_track_joined(json.fragments, json.protocol,
|
|
|
|
json.is_live)
|
|
|
|
|
|
|
|
-- normal video or single track
|
|
|
|
streamurl = edl_track or json.url
|
|
|
|
set_http_headers(json.http_headers)
|
|
|
|
else
|
|
|
|
msg.error("No URL found in JSON data.")
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
msg.debug("streamurl: " .. streamurl)
|
|
|
|
|
|
|
|
mp.set_property("stream-open-filename", streamurl:gsub("^data:", "data://", 1))
|
|
|
|
|
|
|
|
mp.set_property("file-local-options/force-media-title", json.title)
|
|
|
|
|
|
|
|
-- add subtitles
|
|
|
|
if not (json.requested_subtitles == nil) then
|
|
|
|
for lang, sub_info in pairs(json.requested_subtitles) do
|
|
|
|
msg.verbose("adding subtitle ["..lang.."]")
|
|
|
|
|
|
|
|
local sub = nil
|
|
|
|
|
|
|
|
if not (sub_info.data == nil) then
|
|
|
|
sub = "memory://"..sub_info.data
|
|
|
|
elseif not (sub_info.url == nil) then
|
|
|
|
sub = sub_info.url
|
|
|
|
end
|
|
|
|
|
|
|
|
if not (sub == nil) then
|
|
|
|
mp.commandv("sub-add", sub,
|
|
|
|
"auto", sub_info.ext, lang)
|
|
|
|
else
|
|
|
|
msg.verbose("No subtitle data/url for ["..lang.."]")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
-- add chapters from description
|
|
|
|
if not (json.description == nil) and not (json.duration == nil) then
|
|
|
|
chapter_list = extract_chapters(json.description, json.duration)
|
|
|
|
end
|
|
|
|
|
|
|
|
-- set start time
|
2017-06-08 18:45:49 +00:00
|
|
|
if not (json.start_time == nil) and
|
2017-06-09 07:08:54 +00:00
|
|
|
not option_was_set("start") and
|
|
|
|
not option_was_set_locally("start") then
|
2017-04-22 20:47:34 +00:00
|
|
|
msg.debug("Setting start to: " .. json.start_time .. " secs")
|
|
|
|
mp.set_property("file-local-options/start", json.start_time)
|
|
|
|
end
|
|
|
|
|
|
|
|
-- set aspect ratio for anamorphic video
|
|
|
|
if not (json.stretched_ratio == nil) and
|
|
|
|
not option_was_set("video-aspect") then
|
|
|
|
mp.set_property('file-local-options/video-aspect', json.stretched_ratio)
|
|
|
|
end
|
|
|
|
|
|
|
|
-- for rtmp
|
|
|
|
if (json.protocol == "rtmp") then
|
|
|
|
local rtmp_prop = append_rtmp_prop(nil,
|
|
|
|
"rtmp_tcurl", streamurl)
|
|
|
|
rtmp_prop = append_rtmp_prop(rtmp_prop,
|
|
|
|
"rtmp_pageurl", json.page_url)
|
|
|
|
rtmp_prop = append_rtmp_prop(rtmp_prop,
|
|
|
|
"rtmp_playpath", json.play_path)
|
|
|
|
rtmp_prop = append_rtmp_prop(rtmp_prop,
|
|
|
|
"rtmp_swfverify", json.player_url)
|
|
|
|
rtmp_prop = append_rtmp_prop(rtmp_prop,
|
|
|
|
"rtmp_swfurl", json.player_url)
|
|
|
|
rtmp_prop = append_rtmp_prop(rtmp_prop,
|
|
|
|
"rtmp_app", json.app)
|
|
|
|
|
|
|
|
mp.set_property("file-local-options/stream-lavf-o", rtmp_prop)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-01-24 19:54:35 +00:00
|
|
|
mp.add_hook("on_load", 10, function ()
|
2014-11-19 17:37:23 +00:00
|
|
|
local url = mp.get_property("stream-open-filename")
|
|
|
|
|
|
|
|
if (url:find("http://") == 1) or (url:find("https://") == 1)
|
|
|
|
or (url:find("ytdl://") == 1) then
|
|
|
|
|
2015-10-10 22:35:35 +00:00
|
|
|
-- check for youtube-dl in mpv's config dir
|
|
|
|
if not (ytdl.searched) then
|
|
|
|
local ytdl_mcd = mp.find_config_file("youtube-dl")
|
|
|
|
if not (ytdl_mcd == nil) then
|
|
|
|
msg.verbose("found youtube-dl at: " .. ytdl_mcd)
|
|
|
|
ytdl.path = ytdl_mcd
|
|
|
|
end
|
|
|
|
ytdl.searched = true
|
|
|
|
end
|
|
|
|
|
2014-11-19 17:37:23 +00:00
|
|
|
-- strip ytdl://
|
|
|
|
if (url:find("ytdl://") == 1) then
|
|
|
|
url = url:sub(8)
|
|
|
|
end
|
|
|
|
|
2014-11-19 22:33:28 +00:00
|
|
|
local format = mp.get_property("options/ytdl-format")
|
2015-02-22 20:32:42 +00:00
|
|
|
local raw_options = mp.get_property_native("options/ytdl-raw-options")
|
2015-10-23 16:22:54 +00:00
|
|
|
local allsubs = true
|
2014-11-19 22:33:28 +00:00
|
|
|
|
|
|
|
local command = {
|
2015-10-23 16:22:54 +00:00
|
|
|
ytdl.path, "--no-warnings", "-J", "--flat-playlist",
|
2015-08-27 11:42:04 +00:00
|
|
|
"--sub-format", "ass/srt/best", "--no-playlist"
|
2014-11-19 22:33:28 +00:00
|
|
|
}
|
2015-04-27 20:30:10 +00:00
|
|
|
|
2015-09-30 20:28:01 +00:00
|
|
|
-- Checks if video option is "no", change format accordingly,
|
|
|
|
-- but only if user didn't explicitly set one
|
|
|
|
if (mp.get_property("options/vid") == "no")
|
|
|
|
and not option_was_set("ytdl-format") then
|
|
|
|
|
2017-01-31 18:22:57 +00:00
|
|
|
format = "bestaudio/best"
|
2015-05-09 19:41:44 +00:00
|
|
|
msg.verbose("Video disabled. Only using audio")
|
|
|
|
end
|
2015-04-27 20:30:10 +00:00
|
|
|
|
2016-09-22 18:30:06 +00:00
|
|
|
if (format == "") then
|
2017-01-31 18:22:57 +00:00
|
|
|
format = "bestvideo+bestaudio/best"
|
2014-11-19 22:33:28 +00:00
|
|
|
end
|
2016-09-22 18:30:06 +00:00
|
|
|
table.insert(command, "--format")
|
2017-01-31 18:22:57 +00:00
|
|
|
table.insert(command, format)
|
2015-04-09 13:26:12 +00:00
|
|
|
|
2015-02-22 20:32:42 +00:00
|
|
|
for param, arg in pairs(raw_options) do
|
|
|
|
table.insert(command, "--" .. param)
|
|
|
|
if (arg ~= "") then
|
|
|
|
table.insert(command, arg)
|
|
|
|
end
|
2015-10-23 16:22:54 +00:00
|
|
|
if (param == "sub-lang") and (arg ~= "") then
|
|
|
|
allsubs = false
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
if (allsubs == true) then
|
|
|
|
table.insert(command, "--all-subs")
|
2015-02-22 20:32:42 +00:00
|
|
|
end
|
2014-11-19 22:33:28 +00:00
|
|
|
table.insert(command, "--")
|
|
|
|
table.insert(command, url)
|
2015-07-18 13:34:15 +00:00
|
|
|
msg.debug("Running: " .. table.concat(command,' '))
|
2015-06-27 19:09:12 +00:00
|
|
|
local es, json, result = exec(command)
|
2014-11-19 17:37:23 +00:00
|
|
|
|
|
|
|
if (es < 0) or (json == nil) or (json == "") then
|
2015-06-27 19:09:12 +00:00
|
|
|
if not result.killed_by_us then
|
|
|
|
msg.warn("youtube-dl failed, trying to play URL directly ...")
|
|
|
|
end
|
2014-11-19 17:37:23 +00:00
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
local json, err = utils.parse_json(json)
|
|
|
|
|
|
|
|
if (json == nil) then
|
|
|
|
msg.error("failed to parse JSON data: " .. err)
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
2015-01-03 02:38:23 +00:00
|
|
|
msg.verbose("youtube-dl succeeded!")
|
2014-11-19 17:37:23 +00:00
|
|
|
|
|
|
|
-- what did we get?
|
|
|
|
if not (json["direct"] == nil) and (json["direct"] == true) then
|
|
|
|
-- direct URL, nothing to do
|
|
|
|
msg.verbose("Got direct URL")
|
|
|
|
return
|
2015-08-27 11:42:04 +00:00
|
|
|
elseif not (json["_type"] == nil)
|
2015-10-06 15:06:11 +00:00
|
|
|
and ((json["_type"] == "playlist")
|
|
|
|
or (json["_type"] == "multi_video")) then
|
2014-11-19 17:37:23 +00:00
|
|
|
-- a playlist
|
|
|
|
|
2015-01-16 05:59:16 +00:00
|
|
|
if (#json.entries == 0) then
|
|
|
|
msg.warn("Got empty playlist, nothing to play.")
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
|
2014-11-26 16:36:23 +00:00
|
|
|
-- some funky guessing to detect multi-arc videos
|
2016-05-29 20:22:53 +00:00
|
|
|
if (not (json.entries[1]["_type"] == "url_transparent")) and
|
|
|
|
(not (json.entries[1]["webpage_url"] == nil)
|
2017-04-22 20:53:48 +00:00
|
|
|
and (json.entries[1]["webpage_url"] == json["webpage_url"]))
|
|
|
|
and not (json.entries[1].url == nil) then
|
2014-11-26 16:36:23 +00:00
|
|
|
msg.verbose("multi-arc video detected, building EDL")
|
|
|
|
|
2017-01-30 15:57:28 +00:00
|
|
|
local playlist = edl_track_joined(json.entries)
|
2014-11-19 17:37:23 +00:00
|
|
|
|
2014-11-26 16:36:23 +00:00
|
|
|
msg.debug("EDL: " .. playlist)
|
|
|
|
|
2015-01-24 19:54:35 +00:00
|
|
|
-- can't change the http headers for each entry, so use the 1st
|
|
|
|
if json.entries[1] then
|
|
|
|
set_http_headers(json.entries[1].http_headers)
|
|
|
|
end
|
2014-11-26 16:36:23 +00:00
|
|
|
|
|
|
|
mp.set_property("stream-open-filename", playlist)
|
|
|
|
if not (json.title == nil) then
|
2015-10-06 15:06:11 +00:00
|
|
|
mp.set_property("file-local-options/force-media-title",
|
|
|
|
json.title)
|
2014-11-26 16:36:23 +00:00
|
|
|
end
|
2014-11-19 17:37:23 +00:00
|
|
|
|
2016-09-11 14:58:05 +00:00
|
|
|
-- there might not be subs for the first segment
|
|
|
|
local entry_wsubs = nil
|
|
|
|
for i, entry in pairs(json.entries) do
|
|
|
|
if not (entry.requested_subtitles == nil) then
|
|
|
|
entry_wsubs = i
|
|
|
|
break
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-11 15:47:05 +00:00
|
|
|
if not (entry_wsubs == nil) and
|
|
|
|
not (json.entries[entry_wsubs].duration == nil) then
|
2016-09-11 14:58:05 +00:00
|
|
|
for j, req in pairs(json.entries[entry_wsubs].requested_subtitles) do
|
2016-05-22 21:18:27 +00:00
|
|
|
local subfile = "edl://"
|
|
|
|
for i, entry in pairs(json.entries) do
|
2016-09-11 14:58:05 +00:00
|
|
|
if not (entry.requested_subtitles == nil) and
|
|
|
|
not (entry.requested_subtitles[j] == nil) then
|
|
|
|
subfile = subfile..edl_escape(entry.requested_subtitles[j].url)
|
|
|
|
else
|
|
|
|
subfile = subfile..edl_escape("memory://WEBVTT")
|
|
|
|
end
|
2017-01-30 15:57:28 +00:00
|
|
|
subfile = subfile..",length="..entry.duration..";"
|
2016-05-22 21:18:27 +00:00
|
|
|
end
|
|
|
|
msg.debug(j.." sub EDL: "..subfile)
|
|
|
|
mp.commandv("sub-add", subfile, "auto", req.ext, j)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-04-22 20:53:48 +00:00
|
|
|
elseif (not (json.entries[1]["_type"] == "url_transparent")) and
|
|
|
|
(not (json.entries[1]["webpage_url"] == nil)
|
|
|
|
and (json.entries[1]["webpage_url"] == json["webpage_url"]))
|
|
|
|
and (#json.entries == 1) then
|
|
|
|
|
|
|
|
msg.verbose("Playlist with single entry detected.")
|
|
|
|
add_single_video(json.entries[1])
|
2014-11-26 16:36:23 +00:00
|
|
|
else
|
|
|
|
|
|
|
|
local playlist = "#EXTM3U\n"
|
|
|
|
for i, entry in pairs(json.entries) do
|
|
|
|
local site = entry.url
|
2016-10-11 21:23:10 +00:00
|
|
|
local title = entry.title
|
|
|
|
|
|
|
|
if not (title == nil) then
|
|
|
|
title = string.gsub(title, '%s+', ' ')
|
|
|
|
playlist = playlist .. "#EXTINF:0," .. title .. "\n"
|
|
|
|
end
|
2014-11-26 16:36:23 +00:00
|
|
|
|
|
|
|
-- some extractors will still return the full info for
|
|
|
|
-- all clips in the playlist and the URL will point
|
|
|
|
-- directly to the file in that case, which we don't
|
|
|
|
-- want so get the webpage URL instead, which is what
|
|
|
|
-- we want
|
2016-05-29 20:22:53 +00:00
|
|
|
if not (json.entries[1]["_type"] == "url_transparent")
|
|
|
|
and not (entry["webpage_url"] == nil) then
|
2014-11-26 16:36:23 +00:00
|
|
|
site = entry["webpage_url"]
|
|
|
|
end
|
|
|
|
|
|
|
|
playlist = playlist .. "ytdl://" .. site .. "\n"
|
|
|
|
end
|
|
|
|
|
|
|
|
mp.set_property("stream-open-filename", "memory://" .. playlist)
|
|
|
|
end
|
2014-11-19 17:37:23 +00:00
|
|
|
|
|
|
|
else -- probably a video
|
2017-04-22 20:47:34 +00:00
|
|
|
add_single_video(json)
|
2014-11-19 17:37:23 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end)
|
2016-09-27 21:23:10 +00:00
|
|
|
|
|
|
|
|
|
|
|
mp.add_hook("on_preloaded", 10, function ()
|
|
|
|
if next(chapter_list) ~= nil then
|
|
|
|
msg.verbose("Setting chapters from video's description")
|
|
|
|
|
|
|
|
mp.set_property_native("chapter-list", chapter_list)
|
|
|
|
chapter_list = {}
|
|
|
|
end
|
|
|
|
end)
|