|
-- Copyright 2017 Martin Wache
|
|
-- VDR Streamdev Client 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 Version 2 of the License.
|
|
-- You can obtain a copy of the License from
|
|
-- https://www.gnu.org/licenses/gpl2.html
|
|
--
|
|
-- VDR Streamdev Client
|
|
-- Version 0.3.4
|
|
--
|
|
-- A script which turns mpv into a client for VDR with the Streamdev-Plugin
|
|
--
|
|
-- Features:
|
|
-- * runs on Windows, Linux and Mac Os. (needs bash and netcat installed)
|
|
-- * easy channel switching a la vdr (with channel group support)
|
|
-- * show current and next epg event if available
|
|
-- * create timers from epg, disable/enable and remove timers
|
|
-- * watch recordings
|
|
--
|
|
-- Short instructions:
|
|
-- 1. Enable the streamdev-server-plugin in vdr
|
|
-- 2. Modify streamdevhosts.conf to contain the clients IP
|
|
-- 3. If you want to have channel names and epg info,
|
|
-- modify svdrphosts.conf to contain the clients IP.
|
|
-- Also netcat ('nc') and bash needs to be installed and in the path.
|
|
-- 4. Place this file in one of mpvs script folders
|
|
-- ( ~/.config/mpv/scripts/) or call mpv with the --script
|
|
-- command line option.
|
|
-- For now --script vdr-streamdev-client.lua is prefered.
|
|
-- 5. start mpv
|
|
-- mpv vdrstream://[vdr-host][:streamdev-port][/channel] [--script vdr-streamdev-client.lua]
|
|
--
|
|
-- When mpv is running in Streamdev client mode, you can use
|
|
-- the keys UP,DOWN, 0-9 to select channels.
|
|
-- ENTER will bring up the channel info display.
|
|
-- The key 'm' will show the menu.
|
|
--
|
|
-- Many thanks to:
|
|
-- - wolfi.m@vdr-portal.de for fixing the dimensions of the time-box
|
|
-- in the channel-info, the progress bar position and pointing
|
|
-- out that I forgot to remove my startup channel.
|
|
-- - jrie@vdr-portal.de for fixing the bash path for windows
|
|
--
|
|
|
|
local config = {
|
|
host="192.168.55.4",
|
|
svdrp_port="6419",
|
|
--svdrp_port="2004",
|
|
streamdev_port="3000",
|
|
-- default startup channel to show
|
|
startup_channel=1,
|
|
-- time after which the '0' key returns to this channel
|
|
previous_channel_time=10,
|
|
-- for how long to show playback/channel info
|
|
show_info_timeout=7,
|
|
-- timeout after which channel entry is assumed to be finished
|
|
channel_switch_timeout=5,
|
|
|
|
--media_dir="/Users/wache/Downloads/mps/",
|
|
media_dir="/Volumes/video",
|
|
-- all media extensions in upper case please!
|
|
media_extensions={".AVI",".MPG",".OGG",".M4A",".M3U",".MP4",".WEBM",},
|
|
|
|
-- if you don't want to use streamdev-streaming for recordings
|
|
-- you can provide the path to VDRs video directory here (mounted locally)
|
|
vdr_video_dir="",
|
|
|
|
-- recording MB/minute to estimate remaining recording time
|
|
mb_per_minute=25,
|
|
|
|
-- how often the current/next epg events are loaded from the server.
|
|
-- In seconds
|
|
epg_nownext_update_time=300,
|
|
-- time after which a schedule for a channel is considered out of date
|
|
-- and updated from the server. In seconds.
|
|
epg_channel_update_time=3600,
|
|
-- how long after the event ended it is still shown. In seconds.
|
|
epg_old_events_linger_time=120,
|
|
|
|
-- how much time before an event the timer starts. In minutes.
|
|
timer_margin_start=5,
|
|
-- how much time after an event the timer stops. In minutes.
|
|
timer_margin_stop=10,
|
|
-- the default lifetime of a recording (see VDRs manual)
|
|
timer_default_lifetime=99,
|
|
-- the default priority of a recording (see VDRs manual)
|
|
timer_default_priority=50,
|
|
|
|
osd_font_pixel_per_char=8,
|
|
|
|
-- osd colors
|
|
osd_background_color="000000",
|
|
osd_background_alpha="70",
|
|
osd_header_color="000090",
|
|
osd_header_alpha="70",
|
|
osd_highlight_color="000090",
|
|
osd_highlight_alpha="70",
|
|
osd_progressbar_fg_color="00F000",
|
|
osd_progressbar_fg_alpha="10",
|
|
osd_progressbar_bg_color="000090",
|
|
osd_progressbar_bg_alpha="10",
|
|
osd_red="0000F0",
|
|
osd_reda="70",
|
|
osd_green="00F000",
|
|
osd_greena="70",
|
|
osd_yellow="00F0F0",
|
|
osd_yellowa="70",
|
|
osd_blue="F00000",
|
|
osd_bluea="70",
|
|
osd_message_color="007700",
|
|
osd_message_alpha="10",
|
|
osd_confirm_color="007777",
|
|
osd_confirm_alpha="10",
|
|
|
|
osd_top_menu=20,
|
|
osd_left_menu=20,
|
|
osd_width_menu=430,
|
|
osd_height_menu=242,
|
|
osd_menu_max_items=9,
|
|
osd_menu_item_height=20,
|
|
osd_max_rows = 14,
|
|
|
|
osd_message_left=20,
|
|
osd_message_top=230,
|
|
osd_message_width=430,
|
|
osd_message_height=20,
|
|
|
|
osd_info_left=20,
|
|
osd_info_top=180,
|
|
osd_info_width=430,
|
|
osd_info_height=80,
|
|
}
|
|
require 'mp.options'
|
|
read_options(config,'vdr-streamdev-client')
|
|
local assdraw = require "mp.assdraw"
|
|
|
|
local channels = { }
|
|
local chno_to_idx = {}
|
|
local chid_to_idx = {}
|
|
local startup = 1
|
|
local has_svdrp = 0
|
|
local vdruri
|
|
local utils = require 'mp.utils'
|
|
local channel_idx=nil
|
|
local next_channel=0
|
|
local channel_timer
|
|
local last_channel=1
|
|
local next_last_channel=1
|
|
local update_last_channel_timeout
|
|
local disk_space_available=nil
|
|
local disk_space_free=nil
|
|
local disk_space_percent=nil
|
|
local epginfo = {}
|
|
local epginfo_time = {}
|
|
local epg_timer -- refreshes the epg info regulary
|
|
local timerinfo = {}
|
|
|
|
local vw=495
|
|
local vh=275
|
|
|
|
-- ************************* misc ***********************
|
|
|
|
function ends_with(str,str_end)
|
|
local str_len=str:len()
|
|
return str:sub(1+str:len()-str_end:len(),str_len)==str_end
|
|
end
|
|
|
|
function strip_end(str,str_end)
|
|
local str_len=str:len()
|
|
return str:sub(1,str:len()-str_end:len()+1)
|
|
end
|
|
|
|
function toArray(i)
|
|
local array={}
|
|
for v in i do
|
|
array[#array+1]=v
|
|
end
|
|
return array
|
|
end
|
|
|
|
function slice(tbl,first,last)
|
|
local s={}
|
|
for i = first or 1, last or #tbl do
|
|
s[#s+1] = tbl[i]
|
|
end
|
|
return s
|
|
end
|
|
|
|
-- ************************* state machine stuff **********************
|
|
local state={}
|
|
local state_livetv
|
|
local state_playback
|
|
local state_channel_info
|
|
local main_menu_items
|
|
|
|
function update_state()
|
|
local cstate=curr_state()
|
|
if (cstate.update_state) then
|
|
cstate:update_state()
|
|
end
|
|
end
|
|
|
|
function update_osd()
|
|
local cstate=curr_state()
|
|
mp.log("info","update_osd "..cstate.name)
|
|
local ass
|
|
if (cstate.update_osd) then
|
|
ass = cstate:update_osd()
|
|
else
|
|
ass = assdraw.ass_new()
|
|
end
|
|
if cstate.message ~= nil or cstate.confirm ~= nil then
|
|
-- message box
|
|
ass:new_event()
|
|
ass:pos(config.osd_message_left, config.osd_message_top)
|
|
if cstate.confirm ~= nil then
|
|
ass_color(ass,config.osd_confirm_color)
|
|
ass_alpha(ass,config.osd_confirm_alpha)
|
|
else
|
|
ass_color(ass,config.osd_message_color)
|
|
ass_alpha(ass,config.osd_message_alpha)
|
|
end
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_message_width,config.osd_message_height)
|
|
ass:draw_stop()
|
|
|
|
-- print message
|
|
ass:new_event()
|
|
ass:pos(config.osd_message_left, config.osd_message_top)
|
|
if cstate.confirm ~= nil then
|
|
ass:append(cstate.confirm)
|
|
else
|
|
ass:append(cstate.message)
|
|
end
|
|
end
|
|
|
|
mp.set_osd_ass(0, 0, ass.text)
|
|
end
|
|
|
|
function state_update_timeout()
|
|
local cstate=curr_state()
|
|
if cstate.timeout then
|
|
if cstate.timer == nil then
|
|
cstate.timer=mp.add_timeout(cstate.timeout,state_back)
|
|
else
|
|
cstate.timer:kill()
|
|
cstate.timer:resume()
|
|
end
|
|
end
|
|
|
|
if cstate.update_osd_timeout then
|
|
if cstate.osd_timer == nil then
|
|
cstate.osd_timer=mp.add_periodic_timer(cstate.update_osd_timeout,
|
|
function()
|
|
update_state()
|
|
update_osd()
|
|
end)
|
|
else
|
|
cstate.osd_timer:kill()
|
|
cstate.osd_timer:resume()
|
|
end
|
|
end
|
|
end
|
|
|
|
function state_remove_timeouts()
|
|
local cstate=curr_state()
|
|
if cstate.timer then
|
|
cstate.timer:kill()
|
|
end
|
|
if cstate.osd_timer then
|
|
cstate.osd_timer:kill()
|
|
end
|
|
end
|
|
|
|
function update_hide_osd_timeout()
|
|
local cstate=curr_state()
|
|
if cstate.hide_osd_timeout then
|
|
if cstate.hide_osd_timer ~= nil then
|
|
cstate.hide_osd_timer:kill()
|
|
end
|
|
cstate.hide_osd_timer=mp.add_timeout(cstate.hide_osd_timeout,
|
|
function()
|
|
cstate.update_osd=nil
|
|
update_osd()
|
|
end)
|
|
end
|
|
cstate.hide_osd_timeout=nil
|
|
end
|
|
|
|
function new_state(nstate)
|
|
table.insert(state,nstate)
|
|
mp.log("info","state_new "..nstate.name)
|
|
state_update_timeout()
|
|
update_state()
|
|
update_hide_osd_timeout()
|
|
update_osd()
|
|
end
|
|
|
|
function state_remove_including(name)
|
|
local cstate=curr_state()
|
|
while #state>1 and name ~= cstate.name do
|
|
state_back()
|
|
cstate=curr_state()
|
|
end
|
|
-- remove the state the name
|
|
state_back()
|
|
end
|
|
|
|
function state_back_to(name)
|
|
local cstate=curr_state()
|
|
while #state>1 and name ~= cstate.name do
|
|
state_back()
|
|
cstate=curr_state()
|
|
end
|
|
end
|
|
|
|
function state_back()
|
|
local cstate=curr_state()
|
|
state_remove_timeouts()
|
|
if #state>1 then
|
|
table.remove(state)
|
|
end
|
|
cstate=curr_state()
|
|
mp.log("info","state_back, new "..cstate.name)
|
|
update_state()
|
|
update_osd()
|
|
end
|
|
|
|
function curr_state()
|
|
return state[#state]
|
|
end
|
|
|
|
-- *********************** OSD stuff *******************************
|
|
|
|
function ass_color(ass,bgr)
|
|
ass:append("{\\1c&H"..bgr.."&}")
|
|
end
|
|
function ass_bdcolor(ass,bgr)
|
|
ass:append("{\\3c&H"..bgr.."&}")
|
|
end
|
|
function ass_alpha(ass,alpha)
|
|
ass:append("{\\1a&H"..alpha.."}")
|
|
end
|
|
function ass_bdalpha(ass,alpha)
|
|
ass:append("{\\3a&H"..alpha.."}")
|
|
end
|
|
function ass_scale_font(ass,scale)
|
|
ass:append("{\\fscx"..scale.."\\fscy"..scale.."}")
|
|
end
|
|
function ass_clip(ass,x1,y1,x2,y2)
|
|
ass:append("{\\clip("..x1..","..y1..","..x2..","..y2.."}")
|
|
end
|
|
|
|
local function vdrtime2str(t)
|
|
return t:sub(1,2)..":"..t:sub(3,5)
|
|
end
|
|
|
|
local function print_time(t)
|
|
if (t == nil) then
|
|
return " "
|
|
end
|
|
return os.date('%H:%M',t)
|
|
end
|
|
|
|
local function print_date(t)
|
|
if (t == nil) then
|
|
return " "
|
|
end
|
|
return os.date('%a %d.%m',t)
|
|
end
|
|
|
|
-- local fake time stamp
|
|
local function lts(options)
|
|
if options.hour == nil then options.hour=0 end
|
|
if options.min == nil then options.min=0 end
|
|
return ((((options.year-1970)*366+options.month)*31+options.day)*24+
|
|
options.hour)*60+options.min
|
|
end
|
|
|
|
local function to_lts(date, time)
|
|
local year=tonumber(date:sub(1,4))
|
|
local month=tonumber(date:sub(6,7))
|
|
local day=tonumber(date:sub(9,10))
|
|
local min=tonumber(time:sub(3,4))
|
|
local hour=tonumber(time:sub(1,2))
|
|
--return os.time{year=year,month=month,day=day,hour=hour,minute=min}
|
|
return lts{year=year,month=month,day=day,
|
|
hour=hour,min=min}
|
|
end
|
|
|
|
local function format_epg(epg_info)
|
|
if epg_info == nil then return "" end
|
|
|
|
local msg
|
|
msg=print_time(epg_info['start'])
|
|
if (epg_info.timer_status =="T") then
|
|
msg= msg.." REC: "
|
|
end
|
|
if (epg_info['title'] ~= nil) then
|
|
msg = msg.." "..epg_info['title']
|
|
end
|
|
return msg
|
|
end
|
|
|
|
local function date_format_epg(epg_info)
|
|
local msg=format_epg(epg_info)
|
|
msg = print_date(epg_info.start) .. " " .. msg
|
|
return msg
|
|
end
|
|
|
|
local function print_duration(t)
|
|
if t==nil then
|
|
return "xx:xx:xx"
|
|
end
|
|
local h=math.floor(t/3600)
|
|
local m=math.floor(t%3600/60)
|
|
local s=t%60
|
|
return string.format("%02d:%02d:%02d",h,m,s)
|
|
end
|
|
|
|
function curr_channel_id()
|
|
local cinfo = channels[channel_idx]
|
|
return cinfo and cinfo['id'] or nil
|
|
end
|
|
|
|
function channel_id_to_idx(cid)
|
|
return chid_to_idx[cid]
|
|
end
|
|
|
|
function channel_info_from_cid(cid)
|
|
return channels[chid_to_idx[cid]]
|
|
end
|
|
|
|
function draw_progressbar(ass,left,top, width, height, part)
|
|
ass:new_event()
|
|
ass:pos(left, top)
|
|
ass_color(ass,config.osd_progressbar_bg_color)
|
|
ass_alpha(ass,config.osd_progressbar_bg_alpha)
|
|
ass_bdcolor(ass,config.osd_progressbar_bg_color)
|
|
ass_bdalpha(ass,config.osd_progressbar_bg_alpha)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,width,height)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
|
|
if part <0 then return end
|
|
ass:pos(left, top)
|
|
ass_color(ass,config.osd_progressbar_fg_color)
|
|
ass_alpha(ass,config.osd_progressbar_fg_alpha)
|
|
ass_bdcolor(ass,config.osd_progressbar_fg_color)
|
|
ass_bdalpha(ass,config.osd_progressbar_fg_alpha)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,part*width,height)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
end
|
|
|
|
function show_playback_info(self)
|
|
--local time_pos = mp.get_property_native("time-pos")
|
|
local time_pos = mp.get_property_native("playback-time")
|
|
local max_time = mp.get_property_native("duration")
|
|
local ass = assdraw.ass_new()
|
|
|
|
-- channel info box
|
|
ass:new_event()
|
|
ass:pos(config.osd_info_left, config.osd_info_top)
|
|
ass_color(ass,config.osd_background_color)
|
|
ass_alpha(ass,config.osd_background_alpha)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_info_width,config.osd_info_height)
|
|
ass:draw_stop()
|
|
|
|
-- print current playback time
|
|
ass:new_event()
|
|
ass:pos(config.osd_info_left, config.osd_info_top)
|
|
ass:append(print_duration(time_pos))
|
|
|
|
-- print playback length
|
|
ass:new_event()
|
|
ass:pos(config.osd_info_width-80, config.osd_info_top)
|
|
ass:append(print_duration(max_time))
|
|
|
|
-- print recording name
|
|
ass:new_event()
|
|
ass:pos(config.osd_info_left+80, config.osd_info_top)
|
|
ass_clip(ass,config.osd_info_left+80,config.osd_info_top,
|
|
config.osd_info_left+config.osd_info_width-100,config.osd_info_top+20)
|
|
ass_scale_font(ass,80)
|
|
ass:append(self.rinfo['name'])
|
|
|
|
if time_pos~= nil and max_time~= nil then
|
|
draw_progressbar(ass,config.osd_info_left+10,config.osd_info_top+30,
|
|
config.osd_info_width-config.osd_info_left-10,20,time_pos/max_time)
|
|
end
|
|
|
|
return ass
|
|
end
|
|
|
|
function show_channel_info(self)
|
|
local ass = assdraw.ass_new()
|
|
local cidx = next_channel==0 and channel_idx or chno_to_idx[next_channel]
|
|
local cinfo = cidx and channels[cidx] or nil
|
|
local chno = cinfo and cinfo.no or cidx
|
|
if next_channel ~= 0 then
|
|
-- channel switching by entering a number
|
|
chno = next_channel
|
|
cidx = chno_to_idx[chno]
|
|
cinfo = cidx and channels[cidx] or nil
|
|
else
|
|
cidx = channel_idx
|
|
cinfo = channels[cidx]
|
|
chno = cinfo and cinfo.no or cidx
|
|
end
|
|
|
|
-- channel info box
|
|
ass:pos(config.osd_info_left, config.osd_info_top)
|
|
ass_color(ass,config.osd_background_color)
|
|
ass_alpha(ass,config.osd_background_alpha)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_info_width,config.osd_info_height)
|
|
ass:draw_stop()
|
|
|
|
-- info time box
|
|
ass:new_event()
|
|
ass:pos(config.osd_info_left, config.osd_info_top)
|
|
ass_color(ass,config.osd_header_color)
|
|
ass_alpha(ass,config.osd_header_alpha)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,55,23)
|
|
ass:draw_stop()
|
|
|
|
-- print time
|
|
ass:new_event()
|
|
ass:pos(config.osd_info_left, config.osd_info_top)
|
|
ass:append(os.date("%H:%M"))
|
|
|
|
-- channel name
|
|
ass:new_event()
|
|
ass:pos(config.osd_info_left+70, config.osd_info_top)
|
|
if cinfo and not cinfo.is_group_separator then
|
|
ass:append(chno)
|
|
if next_channel~=0 then
|
|
ass:append("_")
|
|
end
|
|
end
|
|
if cinfo then ass:append(" "..tostring(cinfo['name'])) end
|
|
ass:new_event()
|
|
|
|
local cid = cinfo and cinfo['id'] or nil
|
|
local einfo=get_epgnow(cid)
|
|
if einfo then
|
|
-- epg progress bar
|
|
local dwidth=200
|
|
local dheight=5
|
|
if einfo['start'] ~= nil and einfo['duration'] ~= nil then
|
|
local part = (os.time()-tonumber(einfo['start']))/
|
|
tonumber(einfo['duration'])
|
|
draw_progressbar(ass,config.osd_info_left+1, config.osd_info_top+24,
|
|
dwidth,dheight,part)
|
|
end
|
|
|
|
-- epg now info
|
|
ass:pos(config.osd_info_left+2, config.osd_info_top+35)
|
|
ass_clip(ass,config.osd_info_left,config.osd_info_top+35,
|
|
config.osd_info_left+config.osd_info_width,
|
|
config.osd_info_top+55)
|
|
ass_scale_font(ass,80)
|
|
ass:append(format_epg(einfo))
|
|
ass:new_event()
|
|
end
|
|
|
|
einfo = get_epgnext(cid)
|
|
if einfo ~= nil then
|
|
-- epg next info
|
|
ass:pos(config.osd_info_left+2, config.osd_info_top+55)
|
|
ass_clip(ass,config.osd_info_left,config.osd_info_top+55,
|
|
config.osd_info_left+config.osd_info_width,
|
|
config.osd_info_top+75)
|
|
ass_scale_font(ass,80)
|
|
ass:append(format_epg(einfo))
|
|
ass:new_event()
|
|
end
|
|
|
|
return ass
|
|
end
|
|
|
|
function create_menu_base(options)
|
|
local ass = assdraw.ass_new()
|
|
local bg = config.osd_background_color
|
|
local bga = config.osd_background_alpha
|
|
local hd = config.osd_header_color
|
|
local hda = config.osd_header_alpha
|
|
local red = config.osd_red
|
|
local reda = config.osd_reda
|
|
local green = config.osd_green
|
|
local greena = config.osd_greena
|
|
local yellow = config.osd_yellow
|
|
local yellowa = config.osd_yellowa
|
|
local blue = config.osd_blue
|
|
local bluea = config.osd_bluea
|
|
|
|
-- menu box
|
|
ass:pos(config.osd_left_menu, config.osd_top_menu)
|
|
ass_color(ass,bg)
|
|
ass_alpha(ass,bga)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_width_menu,config.osd_height_menu)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
|
|
-- header box
|
|
ass:pos(config.osd_left_menu, config.osd_top_menu)
|
|
ass_color(ass,hd)
|
|
ass_alpha(ass,hda)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_width_menu,20)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
|
|
-- header
|
|
ass:pos(config.osd_left_menu, config.osd_top_menu)
|
|
ass:append(os.date("%H:%M"))
|
|
if options and options.name then ass:append(" "..options.name) end
|
|
ass:new_event()
|
|
|
|
-- footer
|
|
ass:pos(config.osd_left_menu,config.osd_top_menu+config.osd_height_menu-20)
|
|
ass_color(ass,red)
|
|
ass_alpha(ass,reda)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_width_menu/4,20)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
if options and options.red then
|
|
ass:pos(config.osd_left_menu+2,config.osd_top_menu+config.osd_height_menu-20)
|
|
ass_scale_font(ass,80)
|
|
ass:append(options.red)
|
|
ass:new_event()
|
|
end
|
|
|
|
ass:pos(config.osd_left_menu+config.osd_width_menu/4,config.osd_top_menu+config.osd_height_menu-20)
|
|
ass_color(ass,green)
|
|
ass_alpha(ass,greena)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_width_menu/4,20)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
if options and options.green then
|
|
ass:pos(config.osd_left_menu+config.osd_width_menu/4+2,config.osd_top_menu+config.osd_height_menu-20)
|
|
ass_scale_font(ass,80)
|
|
ass:append(options.green)
|
|
ass:new_event()
|
|
end
|
|
|
|
ass:pos(config.osd_left_menu+config.osd_width_menu/4*2,config.osd_top_menu+config.osd_height_menu-20)
|
|
ass_color(ass,yellow)
|
|
ass_alpha(ass,yellowa)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_width_menu/4,20)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
if options and options.yellow then
|
|
ass:pos(config.osd_left_menu+config.osd_width_menu/4*2+2,config.osd_top_menu+config.osd_height_menu-20)
|
|
ass_scale_font(ass,80)
|
|
ass:append(options.yellow)
|
|
ass:new_event()
|
|
end
|
|
|
|
ass:pos(config.osd_left_menu+config.osd_width_menu/4*3,config.osd_top_menu+config.osd_height_menu-20)
|
|
ass_color(ass,blue)
|
|
ass_alpha(ass,bluea)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,config.osd_width_menu/4,20)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
if options and options.blue then
|
|
ass:pos(config.osd_left_menu+config.osd_width_menu/4*3+2,config.osd_top_menu+config.osd_height_menu-20)
|
|
ass_scale_font(ass,80)
|
|
ass:append(options.blue)
|
|
ass:new_event()
|
|
end
|
|
|
|
return ass
|
|
end
|
|
|
|
function draw_scrollbar(ass,left,top,width,height,pos,max)
|
|
local part=height/max
|
|
local bheight=part
|
|
if part<10 then bheight=10 end
|
|
if pos<0 or max < 1 then return end
|
|
part = (pos-1)*(height-bheight)/max
|
|
ass:pos(left,top)
|
|
ass_color(ass,config.osd_highlight_color)
|
|
ass_alpha(ass,config.osd_highlight_alpha)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,part,width,part+bheight)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
end
|
|
|
|
local item_w=config.osd_width_menu - 11
|
|
function show_menu(self)
|
|
local ass = create_menu_base{name=self.header,
|
|
red=self.red_name,green=self.green_name,
|
|
yellow=self.yellow_name,blue=self.blue_name}
|
|
if self.selected_item == nil then self.selected_item = 1 end
|
|
if self.items == nil or #self.items == 0 then
|
|
return ass
|
|
end
|
|
if self.start_pos == nil or self.start_pos < 1 then self.start_pos = 1 end
|
|
if self.selected_item>self.start_pos+config.osd_menu_max_items then
|
|
self.start_pos=self.selected_item - config.osd_menu_max_items
|
|
end
|
|
if self.selected_item<self.start_pos then
|
|
self.start_pos=self.selected_item
|
|
end
|
|
local maxi = #self.items>self.start_pos+config.osd_menu_max_items
|
|
and self.start_pos+config.osd_menu_max_items or #self.items
|
|
local draw_item=self.draw_item and self.draw_item or
|
|
draw_column_item(nil,self.column_width)
|
|
for i = self.start_pos,maxi do
|
|
local v = self.items[i]
|
|
local itop= config.osd_top_menu+1+(i-self.start_pos+1)*config.osd_menu_item_height
|
|
if self.selected_item == i then
|
|
ass:pos(config.osd_left_menu, itop)
|
|
ass_color(ass,config.osd_highlight_color)
|
|
ass_alpha(ass,config.osd_highlight_alpha)
|
|
ass:draw_start()
|
|
ass:rect_ccw(0,0,item_w,config.osd_menu_item_height)
|
|
ass:draw_stop()
|
|
ass:new_event()
|
|
end
|
|
if v.draw == nil then
|
|
draw_item(v,ass,config.osd_left_menu+2,itop,item_w,config.osd_menu_item_height)
|
|
else
|
|
v:draw(ass,config.osd_left_menu+2,itop,item_w,config.osd_menu_item_height)
|
|
end
|
|
ass:new_event()
|
|
end
|
|
if #self.items>config.osd_menu_max_items then
|
|
draw_scrollbar(ass,config.osd_left_menu+config.osd_width_menu-10,
|
|
config.osd_top_menu+21,9,config.osd_height_menu-42,
|
|
self.start_pos,#self.items-config.osd_menu_max_items)
|
|
end
|
|
|
|
return ass
|
|
end
|
|
|
|
function menu_handle_key(self,k)
|
|
if k=="UP" then
|
|
self.selected_item = self.selected_item - 1
|
|
elseif k=="DOWN" then
|
|
self.selected_item = self.selected_item + 1
|
|
elseif k=="LEFT" then
|
|
self.selected_item = self.selected_item - config.osd_menu_max_items
|
|
elseif k=="RIGHT" then
|
|
self.selected_item = self.selected_item + config.osd_menu_max_items
|
|
elseif k=="BS" then
|
|
state_back()
|
|
elseif k=="RED" and self.red_action then
|
|
self:red_action()
|
|
elseif k=="GREEN" and self.green_action then
|
|
self:green_action()
|
|
elseif k=="YELLOW" and self.yellow_action then
|
|
self:yellow_action()
|
|
elseif k=="BLUE" and self.blue_action then
|
|
self:blue_action()
|
|
elseif k=="ENTER" then
|
|
local item = self.items[self.selected_item]
|
|
if item and item.action then
|
|
item:action()
|
|
end
|
|
elseif k=="MENU" then
|
|
state_remove_including("main_menu")
|
|
elseif type(k) == "number" and k>=0 and k<=9 then
|
|
self.selected_item = k
|
|
end
|
|
|
|
if self.selected_item then
|
|
if self.items ~= nil and self.selected_item > #self.items then
|
|
self.selected_item = #self.items
|
|
end
|
|
if self.selected_item < 1 then
|
|
self.selected_item = 1
|
|
end
|
|
end
|
|
update_osd()
|
|
end
|
|
|
|
local margin=20
|
|
function split_text(max_len,text)
|
|
local pos = 1
|
|
return function()
|
|
local npos = text:find("\n",pos)
|
|
if npos == nil then npos=text:len()+1 end
|
|
|
|
if npos-pos>max_len then
|
|
-- find space to split the string
|
|
npos=text:find("[ -.+]",pos+max_len-margin>0 and pos+max_len-margin or 0)
|
|
if npos == nil then npos=text:len()+1 end
|
|
end
|
|
|
|
if pos>=text:len() then
|
|
return nil
|
|
end
|
|
local ret = text:sub(pos,npos)
|
|
pos = npos + 1
|
|
return ret
|
|
end
|
|
end
|
|
|
|
-- shows text in self.text
|
|
-- uses self.header, self.title, self.subtitle
|
|
function show_text(self)
|
|
local ass = create_menu_base{name=self.header,
|
|
red=self.red_name,green=self.green_name,
|
|
yellow=self.yellow_name,blue=self.blue_name}
|
|
local i = 0
|
|
local t = config.osd_top_menu + 23
|
|
local l = config.osd_left_menu + 2
|
|
local max_rows=config.osd_max_rows
|
|
local text = self.text and toArray(split_text(config.osd_width_menu/config.osd_font_pixel_per_char/0.8,self.text)) or {}
|
|
|
|
|
|
if self.title then
|
|
-- time, title
|
|
ass:pos(l, t)
|
|
ass_clip(ass,l,t,l+config.osd_width_menu-10,t+25)
|
|
ass:append(tostring(self.title))
|
|
ass:new_event()
|
|
t = t + 25
|
|
max_rows = max_rows - 2
|
|
end
|
|
-- subtitle
|
|
if self.subtitle then
|
|
ass:pos(l, t)
|
|
ass_clip(ass,l,t,l+config.osd_width_menu-10,t+20)
|
|
ass_scale_font(ass,80)
|
|
ass:append(tostring(self.subtitle))
|
|
ass:new_event()
|
|
t = t + 20
|
|
max_rows = max_rows - 2
|
|
end
|
|
if self.start_pos == nil then self.start_pos = 1 end
|
|
if self.start_pos > #text-max_rows then self.start_pos = #text-max_rows end
|
|
if self.start_pos < 1 then self.start_pos = 1 end
|
|
local sp=self.start_pos
|
|
if self.text then
|
|
for j=0,max_rows do
|
|
local v = text[j+sp]
|
|
if v then
|
|
ass:pos(l, t + j*13)
|
|
ass_scale_font(ass,70)
|
|
ass:append(v)
|
|
ass:new_event()
|
|
end
|
|
end
|
|
end
|
|
if #text > max_rows+1 then
|
|
draw_scrollbar(ass,config.osd_left_menu+config.osd_width_menu-10,
|
|
config.osd_top_menu+21,9,config.osd_height_menu-42,
|
|
self.start_pos,#text-max_rows-1)
|
|
end
|
|
|
|
return ass
|
|
end
|
|
|
|
function key(k)
|
|
return function()
|
|
local cstate=curr_state()
|
|
mp.log("info","state name "..cstate.name)
|
|
mp.log("info","key "..k)
|
|
if cstate.confirm ~= nil then
|
|
local action=cstate.confirm_action
|
|
cstate.confirm=nil
|
|
cstate.confirm_action=nil
|
|
if k=="ENTER" and action ~= nil then
|
|
action(cstate)
|
|
end
|
|
update_osd()
|
|
return
|
|
end
|
|
if cstate and cstate.handle_key then
|
|
cstate:handle_key(k)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function send_webrequest(path)
|
|
ret = utils.subprocess({
|
|
args= {'bash', '-c', '( printf "GET /'..path
|
|
..' HTTP/1.0\n\n"; sleep 1)|nc '..config.host..' '
|
|
..config.streamdev_port},
|
|
-- args= {'/bin/bash', '-c', 'echo "'..command
|
|
-- ..'" >/dev/tcp/'..config.host..'/'..config.svdrp_port},
|
|
cancellable=false,
|
|
})
|
|
return ret.stdout
|
|
end
|
|
|
|
local function parse_ext3mu(stdout)
|
|
mp.log("info","Parsing ext3mu")
|
|
local state='http_header'
|
|
local ret={}
|
|
local title={}
|
|
for l in string.gmatch(stdout,"[^\r\n]+") do
|
|
if state=='http_header' then
|
|
if l~="HTTP/1.0 200 OK" then
|
|
state="error_http_header"
|
|
break
|
|
end
|
|
state="http_header_content"
|
|
elseif state=="http_header_content" then
|
|
if l~="Content-type: audio/x-mpegurl; charset=UTF-8" then
|
|
state="error_http_content"
|
|
break
|
|
end
|
|
state="content_header"
|
|
elseif state=="content_header" then
|
|
if l~="#EXTM3U" then
|
|
state="error_content_header"
|
|
break
|
|
end
|
|
state="content_line_header"
|
|
elseif state=="content_line_header" then
|
|
if l:sub(1,11)~="#EXTINF:-1," then
|
|
state="error_content_line_header"
|
|
mp.log("info","'"..l:sub(1,11).."'")
|
|
break
|
|
end
|
|
local info=toArray(string.gmatch(l:sub(12),"[^ ]+"))
|
|
title['idx']=info[1]
|
|
title['day']=info[2]
|
|
title['time']=info[3]
|
|
title['name']=table.concat(slice(info,4)," ")
|
|
state = "content_line"
|
|
elseif state=="content_line" then
|
|
title['url']=l
|
|
table.insert(ret,title)
|
|
title = {}
|
|
state = "content_line_header"
|
|
end
|
|
end
|
|
mp.log("info",state)
|
|
return ret
|
|
end
|
|
|
|
local function get_info_svdrp(self)
|
|
mp.log("info","get_info_svdrp "..tostring(self.name))
|
|
local info=parse_lste(send_svdrp(string.format("LSTR %d",self.idx)))
|
|
for i,v in pairs(info) do
|
|
mp.log("info",tostring(i)..":"..tostring(v))
|
|
for j,event in pairs(v) do
|
|
mp.log("info",tostring(j)..":"..tostring(event))
|
|
return event.description,format_epg(event),event.subtitle
|
|
end
|
|
end
|
|
end
|
|
|
|
local function parse_lstr(stdout)
|
|
mp.log("info","Parsing lstr")
|
|
local ret={}
|
|
for i in string.gmatch(stdout,"[^\r\n]+") do
|
|
local code = i:sub(1,3)
|
|
if code == "250" then
|
|
local c = i:sub(5,5)
|
|
local line = i:sub(5)
|
|
local idx,date,time,length,new,name = line:match("(%d+) (%d%d.%d%d.%d%d) (%d%d:%d%d) (%d?%d:%d%d)(%*?) +(.*)")
|
|
local title={
|
|
idx=idx,
|
|
day=date,
|
|
time=time,
|
|
length=length,
|
|
new=new,
|
|
name=name,
|
|
url=string.format("http://%s:%d/%d.rec.ts",config.host,config.streamdev_port,idx),
|
|
info=get_info_svdrp,
|
|
}
|
|
table.insert(ret,title)
|
|
else
|
|
mp.log("info","parse_lstr unknown "..i)
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
local function collect_directories(recordings)
|
|
mp.log("info","collect recordings")
|
|
local ret={}
|
|
local cache_tree={
|
|
entries={},
|
|
child={},
|
|
}
|
|
for i,v in pairs(recordings) do
|
|
local spath=toArray(string.gmatch(v['name'],"[^~]+"))
|
|
local j=1
|
|
local dir=ret
|
|
local cache=cache_tree
|
|
while (j~=#spath) do
|
|
local name=spath[j]
|
|
if cache.child[name] == nil then
|
|
cache.child[name] = {
|
|
entries={},
|
|
child={},
|
|
}
|
|
cache.entries[name]={
|
|
name=name,
|
|
title=name,
|
|
}
|
|
table.insert(dir,cache.entries[name])
|
|
end
|
|
dir=cache.entries[name]
|
|
cache=cache.child[name]
|
|
j = j + 1
|
|
end
|
|
v.title=spath[#spath]
|
|
table.insert(dir,v)
|
|
end
|
|
return ret
|
|
end
|
|
|
|
function send_svdrp(command)
|
|
ret = utils.subprocess({
|
|
args= {'bash', '-c', '(printf "'..command
|
|
..'\n" ; sleep 0.1)|nc '..config.host..' '..config.svdrp_port},
|
|
-- args= {'/bin/bash', '-c', 'echo "'..command
|
|
-- ..'" >/dev/tcp/'..config.host..'/'..config.svdrp_port},
|
|
cancellable=false,
|
|
})
|
|
if ret.error=="init" then
|
|
mp.log("warn","Could not contact VDR server. Do you have 'bash' and 'nc' (netcat) installed?")
|
|
end
|
|
if ret.status ~= 0 then
|
|
mp.log("warn","Could not contact VDR server. Is the SVDRP port "..config.svdrp_port.." correct, is it open and the client's IP in svdrphosts.conf?")
|
|
end
|
|
return ret.stdout
|
|
end
|
|
|
|
function check_for_errors(stdout)
|
|
for i in string.gmatch(stdout,"[^\r\n]+") do
|
|
local code = i:sub(1,3)
|
|
if code:sub(1,1) == "5" then
|
|
return i:sub(5)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function parse_lstc(stdout)
|
|
mp.log("info","Getting channel list")
|
|
for i in string.gmatch(stdout,"[^\r\n]+") do
|
|
local code = i:sub(1,3)
|
|
local line = i:sub(5)
|
|
if (code ~= "250") then
|
|
mp.log("info","Unknown code '"..i.."'")
|
|
else
|
|
local channel_end=i:find(";")
|
|
if (channel_end ==nil) then
|
|
if i:sub(5,5)=="0" then
|
|
-- channel separator
|
|
local cinfo={}
|
|
local start_cno,groupname=i:match("0 :@?(%d*) ?(.*)")
|
|
cinfo.is_group_separator=true
|
|
cinfo.name = groupname
|
|
mp.log("info","found group "..utils.to_string(cinfo))
|
|
table.insert(channels,cinfo)
|
|
end
|
|
else
|
|
-- normal channel
|
|
local channel=i:sub(5,channel_end-1)
|
|
local sp=channel:find(" ")
|
|
if (sp ~= nil) then
|
|
local c =tonumber(channel:sub(0,sp-1))
|
|
local cinfo={}
|
|
cinfo['no']=c
|
|
cinfo['name']=channel:sub(sp+1)
|
|
-- S19.2E-1-1079-28011 ZDFinfo (S19.2E)
|
|
-- ZDFinfo;ZDFvision:11953:HC34M2S0:S19.2E:27500:610=2:620=deu@3,621=mis@3,622=mul@3;625=deu@106:630;631=deu:0:28011:1:1079:0
|
|
local para=toArray(i:sub(channel_end+1):gmatch("[^:]+"))
|
|
if (#para>12) then
|
|
local cid=para[4].."-"..para[11].."-"..para[12].."-"..para[10]
|
|
--mp.log("info",cid)
|
|
cinfo['id']=cid
|
|
else
|
|
mp.log("info","para > 12: "..tostring(#para))
|
|
end
|
|
table.insert(channels,cinfo)
|
|
cinfo.idx=#channels
|
|
chno_to_idx[cinfo.no]=#channels
|
|
if cinfo.id then
|
|
chid_to_idx[cinfo.id]=#channels
|
|
else
|
|
mp.log("info","no channel id "..channel)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function get_channels()
|
|
parse_lstc(send_svdrp('LSTC :groups'))
|
|
if #channels==0 then
|
|
mp.log("warn","Could not load channel list, only basic functionality will be available.")
|
|
|
|
else
|
|
has_svdrp=1
|
|
end
|
|
end
|
|
|
|
local function parse_plug(stdout)
|
|
for i in string.gmatch(stdout,"[^\r\n]+") do
|
|
local code = i:sub(1,3)
|
|
if code == "214" then
|
|
local line = i:sub(5)
|
|
if line == "Available plugins:" then
|
|
elseif line == "End of plugin list" then
|
|
else
|
|
local plugin=line:sub(1,line:find(" ")-1)
|
|
mp.log("info","found plugin "..tostring(plugin))
|
|
if plugin == "svdrposd" then
|
|
table.insert( main_menu_items,#main_menu_items+1,{
|
|
text="Server OSD",
|
|
action = function()
|
|
new_state( create_remote_osd_menu_state() )
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function check_for_plugins()
|
|
parse_plug(send_svdrp("PLUG"))
|
|
end
|
|
|
|
-- ************************* epg stuff ***********************
|
|
|
|
local function parse_stat(line)
|
|
disk_space_available,disk_space_free,disk_space_percent=line:match("(%d+)MB (%d+)MB (%d+)%%")
|
|
end
|
|
|
|
function update_state_disk_header(self)
|
|
if disk_space_available ~= nil then
|
|
local free_m=math.floor(disk_space_free/config.mb_per_minute)
|
|
self.header=string.format("Disk %d%% Free %02d:%02dh",
|
|
disk_space_percent, math.floor(free_m/60), free_m%60)
|
|
end
|
|
end
|
|
|
|
local function parse_event(event,line)
|
|
--mp.log("info","prase_event "..tostring(line))
|
|
if event==nil then event={} end
|
|
local code = line:sub(1,2)
|
|
local value = line:sub(3)
|
|
if code == "C " then
|
|
event.cid=value:sub(1,value:find(" ")-1)
|
|
elseif code == "E " then
|
|
local p=toArray(value:gmatch("[^ ]+"))
|
|
event['start'] = tonumber(p[2])
|
|
event['duration'] = tonumber(p[3])
|
|
event['stop'] = event.start + event.duration
|
|
event.start_date_str=print_date(event.start)
|
|
event.start_time_str=print_time(event.start)
|
|
event.start_lts=lts(os.date("*t",event.start))
|
|
event.stop_lts=lts(os.date("*t",event.stop))
|
|
event.cid=cid
|
|
elseif code == "T " then
|
|
event['title']=value
|
|
elseif code == "S " then
|
|
event['subtitle']=value
|
|
elseif code == "D " then
|
|
event['description']=value
|
|
else
|
|
--mp.log("info","Unknwon code "..tostring(code))
|
|
end
|
|
return event
|
|
end
|
|
|
|
function parse_lste(stdout)
|
|
local epginfo={}
|
|
local cid
|
|
local this_event = {}
|
|
local this_channel
|
|
mp.log("info","Updating epg")
|
|
for i in string.gmatch(stdout,"[^\r\n]+") do
|
|
local code = i:sub(1,3)
|
|
if code == "215" then
|
|
local c = i:sub(5,5)
|
|
local line = i:sub(5)
|
|
if c == "C" then
|
|
-- new channel
|
|
this_event=parse_event({},line)
|
|
this_channel = {}
|
|
cid = this_event.cid
|
|
epginfo[cid]=this_channel
|
|
elseif c =="e" then
|
|
-- end of event
|
|
this_event = {}
|
|
elseif c =="c" then
|
|
-- end of channel
|
|
if #this_channel==0 then epginfo[cid]=nil end
|
|
--mp.log("info","insert "..tostring(cid).." "..#this_channel)
|
|
else
|
|
this_event = parse_event(this_event,line)
|
|
if this_channel[#this_channel]~=this_event and
|
|
this_event.start then
|
|
this_event.cid = cid
|
|
table.insert(this_channel,this_event)
|
|
end
|
|
end
|
|
elseif code == "250" then
|
|
-- the reply to the stat command we send with update epg command
|
|
local line = i:sub(5)
|
|
parse_stat(line)
|
|
end
|
|
end
|
|
return epginfo
|
|
end
|
|
|
|
local function merge_epg_channel(dst,src)
|
|
local di=1
|
|
local si=1
|
|
while dst[1]~=nil and dst[1].start+dst[1].duration
|
|
+config.epg_old_events_linger_time<os.time() do
|
|
--mp.log("info","removing old epg event "..tostring(dst[1].title))
|
|
table.remove(dst,1)
|
|
end
|
|
while si<=#src do
|
|
if dst[di]== nil or dst[di].start > src[si].start then
|
|
table.insert(dst,di,src[si])
|
|
di = di + 1
|
|
si = si + 1
|
|
elseif dst[di].start == src[si].start then
|
|
-- skip it it's already in
|
|
di = di + 1
|
|
si = si + 1
|
|
else
|
|
-- next destination item
|
|
di = di + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
local function merge_epg(dst,src)
|
|
for cid,epg in pairs(src) do
|
|
if dst[cid] ~= nil then
|
|
merge_epg_channel(dst[cid],epg)
|
|
else
|
|
dst[cid]=epg
|
|
end
|
|
end
|
|
end
|
|
|
|
function get_epgnow(cid)
|
|
if epginfo[cid] == nil or epginfo[cid][1] == nil then
|
|
return nil
|
|
end
|
|
local dst=epginfo[cid]
|
|
while dst[1] and dst[1].start+dst[1].duration
|
|
+config.epg_old_events_linger_time<os.time() do
|
|
--mp.log("info","removing old epg event "..tostring(dst[1].title))
|
|
table.remove(dst,1)
|
|
end
|
|
return dst[1]
|
|
end
|
|
|
|
function get_epgnext(cid)
|
|
return epginfo[cid] and (epginfo[cid][2] and epginfo[cid][2] or nil) or nil
|
|
end
|
|
|
|
local function load_epg_now()
|
|
merge_epg(epginfo,parse_lste(send_svdrp("LSTE now")))
|
|
end
|
|
|
|
local function load_epg_next()
|
|
merge_epg(epginfo,parse_lste(send_svdrp("LSTE next\n STAT disk")))
|
|
end
|
|
|
|
local function load_epg_channel(cid)
|
|
mp.log("info","load_epg_channel "..tostring(cid))
|
|
if epginfo_time[cid] == nil or
|
|
epginfo_time[cid]+config.epg_channel_update_time < os.time() then
|
|
merge_epg(epginfo, parse_lste(send_svdrp("LSTE "..cid)))
|
|
epginfo_time[cid]=os.time()
|
|
end
|
|
match_timer_to_event(timerinfo[cid],epginfo[cid])
|
|
end
|
|
|
|
-- ************************* timer stuff ***********************
|
|
|
|
local function parse_lstt(stdout)
|
|
local timerinfo={}
|
|
mp.log("info","Updating timers")
|
|
for i in string.gmatch(stdout,"[^\r\n]+") do
|
|
local code = i:sub(1,3)
|
|
if (code == "250") then
|
|
local timer={}
|
|
local setting_pos=i:find(" ",5)
|
|
timer.id=tonumber(i:sub(5,setting_pos-1))
|
|
local t=toArray(i:sub(setting_pos+1):gmatch("[^:]+"))
|
|
timer.enabled=tonumber(t[1])
|
|
if timer.enabled==1 then
|
|
timer.enabled_str=">"
|
|
elseif timer.enabled==9 then
|
|
timer.enabled_str="#"
|
|
else
|
|
timer.enabled_str=""
|
|
end
|
|
timer.cid=t[2]
|
|
timer.chno=channel_info_from_cid(timer.cid).no
|
|
timer.day=t[3]
|
|
timer.day_str=timer.day:sub(9,10).."."..timer.day:sub(6,7)
|
|
timer.start=t[4]
|
|
timer.start_str=vdrtime2str(timer.start)
|
|
timer.start_lts=to_lts(timer.day,timer.start)
|
|
timer.stop=t[5]
|
|
timer.stop_str=vdrtime2str(timer.stop)
|
|
timer.stop_lts=to_lts(timer.day,timer.stop)
|
|
if timer.stop_lts<timer.start_lts then
|
|
timer.stop_lts=timer.stop_lts+24*60
|
|
end
|
|
timer.priority=t[6]
|
|
timer.lifetime=t[7]
|
|
timer.name=t[8]
|
|
timer.aux= t[9]~=nil and t[9] or ""
|
|
table.insert(timerinfo,timer)
|
|
end
|
|
end
|
|
return timerinfo
|
|
end
|
|
|
|
local function timer_from_event(event)
|
|
local timer={}
|
|
timer.id=nil
|
|
timer.enabled=1
|
|
timer.cid=event.cid
|
|
timer.chno=channel_info_from_cid(event.cid).no
|
|
timer.day=os.date("%Y-%m-%d",event.start-config.timer_margin_start*60)
|
|
timer.start=os.date("%H%M",event.start-config.timer_margin_start*60)
|
|
timer.stop=os.date("%H%M",event.start+event.duration+config.timer_margin_stop*60)
|
|
timer.priority=config.timer_default_priority
|
|
timer.lifetime=config.timer_default_lifetime
|
|
if event.title ~= nil and string.len(event.title)>1 then
|
|
timer.name=event.title
|
|
else
|
|
timer.name=os.date("Rec %Y-%M-%d %H:%m",event.start)
|
|
end
|
|
timer.aux=""
|
|
return timer
|
|
end
|
|
|
|
local function toggle_timer_onoff(timer)
|
|
if timer.enabled==0 then
|
|
timer.enabled=1
|
|
else
|
|
timer.enabled=0
|
|
end
|
|
end
|
|
|
|
local function send_update_timer(timer)
|
|
local timer_str=""
|
|
timer_str = timer_str..timer.enabled..":"
|
|
timer_str = timer_str..timer.cid..":"
|
|
timer_str = timer_str..timer.day..":"
|
|
timer_str = timer_str..timer.start..":"
|
|
timer_str = timer_str..timer.stop..":"
|
|
timer_str = timer_str..timer.priority..":"
|
|
timer_str = timer_str..timer.lifetime..":"
|
|
timer_str = timer_str..timer.name..":"
|
|
timer_str = timer_str..timer.aux
|
|
mp.log("info","send_update_timer: "..tostring(timer_str))
|
|
local result
|
|
if timer.id == nil then
|
|
result =send_svdrp("UPDT "..timer_str)
|
|
else
|
|
timer_str= tostring(timer.id).." "..timer_str
|
|
result =send_svdrp("MODT "..timer_str)
|
|
end
|
|
mp.log("info","send_update_timer: "..tostring(result))
|
|
|
|
return check_for_errors(result)
|
|
end
|
|
|
|
local function send_delete_timer(timer)
|
|
mp.log("info","send_delete_timer "..tostring(timer.id).." "..tostring(timer.name) )
|
|
local result=send_svdrp("DELT "..tostring(timer.id))
|
|
return check_for_errors(result)
|
|
end
|
|
|
|
function load_timers()
|
|
local timers=parse_lstt(send_svdrp("LSTT id"))
|
|
timerinfo={}
|
|
for i,t in pairs(timers) do
|
|
if timerinfo[t.cid] == nil then
|
|
timerinfo[t.cid] = {}
|
|
end
|
|
table.insert(timerinfo[t.cid],t)
|
|
end
|
|
for i,t in pairs(timerinfo) do
|
|
table.sort(t,function(a,b) return a.start_lts<b.start_lts end )
|
|
end
|
|
table.sort(timers,function(a,b) return a.start_lts<b.start_lts end)
|
|
return timers
|
|
end
|
|
|
|
function match_timer_to_event(timers,events, max_events)
|
|
local ei=1
|
|
if events == nil then events={} end
|
|
if max_events == nil then max_events=#events end
|
|
if max_events > #events then max_events=#events end
|
|
--mp.log("info","match_timer_to_event max_events "..max_events)
|
|
while ei<=max_events do
|
|
local ti=1
|
|
local event=events[ei]
|
|
|
|
event.timer_status=" "
|
|
event.timer=nil
|
|
--mp.log("info","event "..date_format_epg(event))
|
|
--mp.log("info","event "..event.start_lts.." "..event.stop_lts)
|
|
while timers and ti<=#timers and timers[ti].start_lts < event.stop_lts do
|
|
--mp.log("info","timer s tls "..timers[ti].start_lts.." stop: "..timers[ti].stop_lts.." "..timers[ti].day.." "..timers[ti].start.." "..timers[ti].stop..tostring(timers[ti].name))
|
|
if timers[ti].enabled == 0 then
|
|
-- ignore disabled timers
|
|
elseif timers[ti].stop_lts < event.start_lts then
|
|
-- do nothing, timer stops before this event starts
|
|
--mp.log("info","stops early "..timers[ti].stop_lts.." "..timers[ti].day.." "..timers[ti].start.." "..timers[ti].stop..tostring(timers[ti].name))
|
|
elseif timers[ti].start_lts < event.start_lts then
|
|
if timers[ti].stop_lts > event.stop_lts then
|
|
event.timer_status="T"
|
|
event.timer=timers[ti]
|
|
timers[ti].event=event
|
|
mp.log("info","found match "..tostring(event.title))
|
|
else
|
|
-- partial recording, missing end
|
|
if event.timer_status == " " then
|
|
event.timer_status="t"
|
|
mp.log("info","found p match missing end "..tostring(event.title))
|
|
--mp.log("info","timer stop "..timers[ti].stop_lts.." "..timers[ti].day.." "..timers[ti].start.." "..timers[ti].stop..tostring(timers[ti].name))
|
|
--mp.log("info","event "..date_format_epg(event))
|
|
--mp.log("info","event "..event.start_lts.." "..event.stop_lts)
|
|
end
|
|
end
|
|
else
|
|
if event.timer_status == " " then
|
|
-- partial recording, missing start
|
|
event.timer_status="t"
|
|
mp.log("info","found p match missing start "..tostring(event.title))
|
|
--mp.log("info","timer stop "..timers[ti].stop_lts.." "..timers[ti].day.." "..timers[ti].start.." "..timers[ti].stop..tostring(timers[ti].name))
|
|
--mp.log("info","event "..date_format_epg(event))
|
|
--mp.log("info","event "..event.start_lts.." "..event.stop_lts)
|
|
end
|
|
end
|
|
ti = ti + 1
|
|
end
|
|
ei = ei +1
|
|
end
|
|
end
|
|
|
|
local function match_nownext_timer_to_event()
|
|
local cid,events
|
|
for cid,events in pairs(epginfo) do
|
|
match_timer_to_event(timerinfo[cid],events,3)
|
|
end
|
|
end
|
|
|
|
-- ************************* remote osd ***********************
|
|
|
|
local function parse_svdrposd_lsto(stdout)
|
|
local osdinfo={
|
|
open=false,
|
|
items={},
|
|
}
|
|
mp.log("info","Updating remote osd")
|
|
for i in string.gmatch(stdout,"[^\r\n]+") do
|
|
local code=i:sub(1,3)
|
|
if code == "920" then
|
|
osdinfo.open=true
|
|
local t=i:sub(5,5)
|
|
if t=="T" then
|
|
osdinfo.title=i:sub(7)
|
|
elseif t=="S" then
|
|
table.insert(osdinfo.items, {text=i:sub(7)})
|
|
osdinfo.selected=#osdinfo.items
|
|
elseif t=="I" then
|
|
table.insert(osdinfo.items, {text=i:sub(7)})
|
|
elseif t=="X" then
|
|
osdinfo.text=i:sub(7)
|
|
elseif t=="R" then
|
|
osdinfo.red=i:sub(7)
|
|
elseif t=="G" then
|
|
osdinfo.green=i:sub(7)
|
|
elseif t=="Y" then
|
|
osdinfo.yellow=i:sub(7)
|
|
elseif t=="B" then
|
|
osdinfo.blue=i:sub(7)
|
|
else
|
|
mp.log("info","unknown osd code "..tostring(i))
|
|
end
|
|
elseif code == "930" then
|
|
osdinfo.open=false
|
|
else
|
|
mp.log("info","unknown osd code "..tostring(i))
|
|
end
|
|
end
|
|
return osdinfo
|
|
end
|
|
|
|
local function switch_channel(no)
|
|
mp.log("info","switch_channel "..no)
|
|
if tonumber(no) == nil then
|
|
no = channel_id_to_idx(no)
|
|
end
|
|
while #channels > 0 and channels[no] and channels[no].is_group_separator do
|
|
no = no + 1
|
|
end
|
|
local sav_channel=channel_idx
|
|
if update_last_channel_timeout ~= nil then
|
|
update_last_channel_timeout:kill()
|
|
end
|
|
update_last_channel_timeout=mp.add_timeout(config.previous_channel_time,
|
|
function()
|
|
mp.log("info","Updating last channel to "..tostring(sav_channel))
|
|
mp.log("info","last_channel :"..tostring(last_channel).." next_lc "..tostring(next_last_channel))
|
|
last_channel=next_last_channel
|
|
next_last_channel=sav_channel
|
|
mp.log("info","last_channel :"..tostring(last_channel).." next_lc "..tostring(next_last_channel))
|
|
end)
|
|
channel_idx=no
|
|
mp.set_property("demuxer-lavf-format","mpegts")
|
|
mp.set_property("keep-open","yes")
|
|
local cinfo = channels[channel_idx]
|
|
if cinfo and cinfo.id then
|
|
mp.commandv("loadfile",vdruri .. cinfo.id)
|
|
else
|
|
mp.commandv("loadfile",vdruri .. channel_idx)
|
|
end
|
|
if cinfo and cinfo.name then
|
|
mp.set_property("force-media-title",cinfo.name)
|
|
end
|
|
mp.log("info","speed "..tostring(mp.get_property("speed")))
|
|
mp.set_property("speed",0.9)
|
|
if speed_timer~=nil then
|
|
speed_timer:kill()
|
|
end
|
|
speed_timer=mp.add_timeout(20,function()
|
|
mp.log("info","resetting speed "..tostring(mp.get_property("speed")))
|
|
mp.set_property("speed",1)
|
|
mp.log("info","resetting speed "..tostring(mp.get_property("speed")))
|
|
end)
|
|
|
|
local state=curr_state()
|
|
if state.name =="livetv" then
|
|
state.update_osd = show_channel_info
|
|
state.hide_osd_timeout=config.show_info_timeout
|
|
update_hide_osd_timeout()
|
|
end
|
|
next_channel=0
|
|
update_osd()
|
|
end
|
|
|
|
local function playback_recording(rinfo)
|
|
local url = rinfo['url']
|
|
mp.log("info","play_rec "..tostring(url))
|
|
mp.commandv("playlist-clear")
|
|
--mp.commandv("playlist-remove","current")
|
|
if type(url)=="table" then
|
|
mp.log("info","loadfile "..tostring(url[1]))
|
|
mp.commandv("loadfile",url[1])
|
|
for i=2,#url do
|
|
mp.log("info","loadfile "..tostring(url[i]))
|
|
mp.commandv("loadfile",url[i],"append")
|
|
end
|
|
else
|
|
mp.commandv("loadfile",url)
|
|
end
|
|
if rinfo and rinfo.title then
|
|
mp.set_property("force-media-title",rinfo.title)
|
|
end
|
|
end
|
|
|
|
local function channel_next()
|
|
mp.log("info","next channel called " .. channel_idx .. " len channels " .. #channels)
|
|
channel_idx = channel_idx + 1
|
|
while #channels and channels[channel_idx].is_group_separator do
|
|
channel_idx = channel_idx + 1
|
|
end
|
|
|
|
if #channels>0 and channel_idx > #channels then
|
|
channel_idx = 1
|
|
end
|
|
switch_channel(channel_idx);
|
|
end
|
|
local function channel_prev()
|
|
mp.log("info","next channel called " .. channel_idx .. " len channels " .. #channels)
|
|
channel_idx = channel_idx - 1
|
|
while #channels and channels[channel_idx] and channels[channel_idx].is_group_separator do
|
|
channel_idx = channel_idx - 1
|
|
end
|
|
if (channel_idx < 1) then
|
|
channel_idx =#channels > 0 and #channels or 1
|
|
end
|
|
switch_channel(channel_idx);
|
|
end
|
|
|
|
local function next_group()
|
|
mp.log("info","next group called")
|
|
local sav = channel_idx
|
|
channel_idx = channel_idx + 1
|
|
while #channels and channels[channel_idx] and not channels[channel_idx].is_group_separator do
|
|
channel_idx = channel_idx + 1
|
|
end
|
|
if #channels and channel_idx>#channels then
|
|
channel_idx=sav
|
|
end
|
|
end
|
|
|
|
local function prev_group()
|
|
mp.log("info","next group called")
|
|
local sav = channel_idx
|
|
channel_idx = channel_idx - 1
|
|
while #channels and channels[channel_idx] and not channels[channel_idx].is_group_separator do
|
|
channel_idx = channel_idx - 1
|
|
end
|
|
if channel_idx < 1 then
|
|
channel_idx = sav
|
|
end
|
|
end
|
|
|
|
|
|
function update_channel_timer()
|
|
if ( channel_timer ~= nil ) then
|
|
channel_timer:kill()
|
|
end
|
|
channel_timer=mp.add_timeout(config.channel_switch_timeout, function()
|
|
if ( next_channel ~= 0 ) then
|
|
local ncid=chno_to_idx[next_channel]
|
|
if ncid then
|
|
switch_channel(ncid)
|
|
else
|
|
switch_channel(next_channel)
|
|
end
|
|
next_channel = 0
|
|
else
|
|
-- switch to current group
|
|
switch_channel(channel_idx)
|
|
end
|
|
end)
|
|
end
|
|
|
|
local function livetv_handle_key(self,key)
|
|
mp.log("info","state name "..self.name)
|
|
local show_osd=function()
|
|
self.update_osd = show_channel_info
|
|
self.hide_osd_timeout = config.show_info_timeout
|
|
update_hide_osd_timeout()
|
|
update_osd()
|
|
end
|
|
if key=="ENTER" then
|
|
if next_channel ~= 0 then
|
|
local ncid=chno_to_idx[next_channel]
|
|
if ncid then
|
|
switch_channel(ncid)
|
|
else
|
|
switch_channel(next_channel)
|
|
end
|
|
next_channel = 0
|
|
elseif channels[channel_idx] and channels[channel_idx].is_group_separator then
|
|
-- confirm group switch
|
|
channel_timer:kill()
|
|
switch_channel(channel_idx)
|
|
elseif self.update_osd == nil then
|
|
show_osd()
|
|
else
|
|
self.update_osd = nil
|
|
update_osd()
|
|
end
|
|
elseif key=="MENU" then
|
|
if has_svdrp==1 then
|
|
-- no menu without svdrp connection
|
|
state_main_menu.selected_item=1
|
|
new_state(state_main_menu)
|
|
end
|
|
elseif key=="UP" then
|
|
channel_next()
|
|
elseif key=="DOWN" then
|
|
channel_prev()
|
|
elseif key=="RIGHT" then
|
|
next_group()
|
|
update_channel_timer()
|
|
show_osd()
|
|
elseif key=="LEFT" then
|
|
prev_group()
|
|
update_channel_timer()
|
|
show_osd()
|
|
elseif type(key) =="number" then
|
|
if key == 0 and next_channel == 0 then
|
|
-- immediatly update last_channel
|
|
mp.log("info","last_channel :"..tostring(last_channel).." next_lc "..tostring(next_last_channel))
|
|
switch_channel(last_channel);
|
|
local sav_channel=last_channel
|
|
last_channel=next_last_channel
|
|
next_last_channel=sav_channel
|
|
mp.log("info","last_channel :"..tostring(last_channel).." next_lc "..tostring(next_last_channel))
|
|
return
|
|
end
|
|
next_channel=next_channel*10+key
|
|
self.update_osd=show_channel_info
|
|
update_osd()
|
|
update_channel_timer()
|
|
end
|
|
end
|
|
|
|
local function on_start()
|
|
local url = mp.get_property("stream-open-filename")
|
|
|
|
if (url:find("vdrstream://") == 1) then
|
|
if ( startup == 1) then
|
|
do_startup(url)
|
|
startup = 0
|
|
end
|
|
-- mp.set_property("stream-open-filename",channels[channel_idx])
|
|
--mp.set_property("cache-size",1024)
|
|
switch_channel(channel_idx)
|
|
--rinfo= {
|
|
--url="blah",
|
|
--name="Diese Datei",
|
|
--}
|
|
--new_state(create_playback_state(rinfo))
|
|
end
|
|
mp.log("info","Lua version " .. _VERSION)
|
|
end
|
|
|
|
function new_show_epgs_state(epg_info,channel_info)
|
|
epg_info = epg_info and epg_info or {description="No data"}
|
|
channel_info = channel_info and channel_info or {}
|
|
local state_show_epg = {
|
|
name = "menu_epg",
|
|
handle_key = function(self,k)
|
|
if k=="ENTER" or k=="BS" then
|
|
state_back()
|
|
elseif k=="DOWN" then
|
|
self.start_pos=self.start_pos+1
|
|
update_osd()
|
|
elseif k=="UP" then
|
|
self.start_pos=self.start_pos-1
|
|
update_osd()
|
|
elseif k=="RED" and self.red_action then
|
|
self:red_action()
|
|
elseif k=="GREEN" and self.green_action then
|
|
self:green_action()
|
|
elseif k=="YELLOW" and self.yellow_action then
|
|
self:yellow_action()
|
|
elseif k=="BLUE" and self.blue_action then
|
|
self:blue_action()
|
|
elseif k=="MENU" then
|
|
state_remove_including("main_menu")
|
|
elseif k=="BLUE" then
|
|
state_back_to("livetv")
|
|
switch_channel(self.cinfo['idx'])
|
|
end
|
|
end,
|
|
|
|
update_osd = show_text,
|
|
text = epg_info.description and epg_info.description:gsub('|','\n') or nil,
|
|
title = format_epg(epg_info),
|
|
subtitle = epg_info['subtitle'],
|
|
cinfo = channel_info,
|
|
red_name = 'Record',
|
|
}
|
|
state_show_epg.red_action = function()
|
|
action_record(state_show_epg,epg_info)
|
|
end
|
|
return state_show_epg
|
|
end
|
|
|
|
-- returns self[part1][part2]..[partn] for col_name 'part1.part2...partn'
|
|
function get_col(self,col_name)
|
|
local p = col_name:find("%.")
|
|
if p then
|
|
return get_col(self[col_name:sub(1,p-1)],col_name:sub(p+1))
|
|
end
|
|
return self[col_name]
|
|
end
|
|
|
|
-- Returns a function to draw menu items
|
|
--
|
|
-- col_names should contain an array of names for get_col(), a function(self) returning
|
|
-- the text to show in to column, or be nil.
|
|
-- if col_names is nil self.text is split at tabulators (\t) and shown in columns
|
|
--
|
|
-- col_width should contain the width of the columns. If it is empty or missing values
|
|
-- the remaining space is equally divided between the remaining columns
|
|
function draw_column_item(col_names,col_width)
|
|
return function(self,ass,left,top,width,height)
|
|
local i
|
|
local l=left
|
|
local n=l
|
|
local cols=col_names
|
|
if cols == nil then
|
|
cols = toArray(self.text:gmatch("[^\t]+"))
|
|
end
|
|
|
|
for i=1,#cols do
|
|
local text
|
|
if col_names == nil then
|
|
text=cols[i]
|
|
elseif type(col_names[i]) == "function" then
|
|
text = col_names[i](self)
|
|
else
|
|
text=get_col(self,col_names[i])
|
|
end
|
|
if col_width and col_width[i] then
|
|
n=l+col_width[i]
|
|
else
|
|
n=l+(left+width-l)/(#cols-i+1)
|
|
end
|
|
if text ~= nil then
|
|
ass:pos(l,top)
|
|
ass_clip(ass,l,top,n-2,top+height)
|
|
ass_scale_font(ass,80)
|
|
ass:append(tostring(text))
|
|
ass:new_event()
|
|
end
|
|
l=n
|
|
end
|
|
end
|
|
end
|
|
|
|
function draw_tabbed_column_item(self,ass,left,top,width,height)
|
|
mp.log("info","draw_tabbed_column_item")
|
|
local cols = toArray(self.text:gmatch("[^\t]+"))
|
|
local pos = 0
|
|
local l = left
|
|
local n
|
|
local tabsize = 4
|
|
for i=1,#cols do
|
|
local text=cols[i]
|
|
if text ~= nil then
|
|
pos = (math.floor((pos + text:len())/tabsize)+1)*tabsize
|
|
n = left + math.floor(pos*config.osd_font_pixel_per_char*0.8)
|
|
ass:pos(l,top)
|
|
ass_clip(ass,l,top,
|
|
(n>left+width and left+width or n)-2,top+height)
|
|
ass_scale_font(ass,80)
|
|
ass:append(tostring(text))
|
|
ass:new_event()
|
|
end
|
|
l=n
|
|
end
|
|
end
|
|
|
|
function action_record(nstate,event)
|
|
local timer=event.timer
|
|
local cid=event.cid
|
|
if timer ~= nil then
|
|
-- edit timer
|
|
new_state(create_edit_timer_menu_state(timer))
|
|
else
|
|
-- new timer
|
|
nstate.message="Creating timer..."
|
|
update_osd()
|
|
timer=timer_from_event(event)
|
|
local ret = send_update_timer(timer)
|
|
if ret then
|
|
nstate.confirm="Error: "..tostring(ret)
|
|
nstate.confirm_action=function() end
|
|
nstate.message=nil
|
|
update_osd()
|
|
else
|
|
nstate.message="Updating..."
|
|
update_osd()
|
|
mp.add_timeout(0.1,function()
|
|
load_timers()
|
|
match_timer_to_event(timerinfo[cid],epginfo[cid])
|
|
nstate.message=nil
|
|
update_osd()
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
|
|
function create_epg_channel_schedule_menu_state(channel_idx)
|
|
local c=channels[channel_idx]
|
|
local cid=c.id
|
|
local items={}
|
|
local nstate= new_menu_state("menu_schedule",items)
|
|
local draw_item = draw_column_item(
|
|
{'einfo.start_date_str','einfo.start_time_str','einfo.timer_status','einfo.title'},
|
|
{85,50,15})
|
|
|
|
local function update_items()
|
|
local schedule=epginfo[cid]
|
|
while #items>0 do
|
|
table.remove(items)
|
|
end
|
|
if schedule ~= nil then
|
|
for i,v in pairs(schedule) do
|
|
table.insert(items,{
|
|
text=date_format_epg(v),
|
|
action = function()
|
|
new_state(new_show_epgs_state(v,c))
|
|
end,
|
|
draw = draw_item,
|
|
einfo = v,
|
|
cinfo = c,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
update_items()
|
|
|
|
mp.add_timeout(0.1,function()
|
|
load_epg_channel(cid)
|
|
update_items()
|
|
nstate.message=nil
|
|
update_osd()
|
|
end)
|
|
nstate.header="Schedule "..c.name
|
|
nstate.message="Loading..."
|
|
nstate.red_name="Record"
|
|
nstate.red_action=function(self)
|
|
local event = self.items[self.selected_item].einfo
|
|
action_record(nstate, event)
|
|
end
|
|
nstate.green_name="Now"
|
|
nstate.green_action=function(self)
|
|
state_back()
|
|
new_state(create_epg_now_next_menu_state("epg_now", get_epgnow, channel_idx))
|
|
end
|
|
nstate.yellow_name="Next"
|
|
nstate.yellow_action=function(self)
|
|
state_back()
|
|
new_state(create_epg_now_next_menu_state("epg_next", get_epgnext, channel_idx))
|
|
end
|
|
nstate.blue_name="Switch"
|
|
nstate.blue_action=function(self)
|
|
state_back_to("livetv")
|
|
switch_channel(items[self.selected_item].cinfo.idx)
|
|
end
|
|
return nstate
|
|
end
|
|
|
|
function create_epg_now_next_menu_state(name,get_epg_fct, sel_cidx)
|
|
local items={}
|
|
local nstate= new_menu_state(name,items)
|
|
if sel_cidx == nil then sel_cidx = channel_idx end
|
|
local draw_item=draw_column_item(
|
|
{'cinfo.name',function(self) return print_time(self.einfo.start) end,'einfo.title'},
|
|
{100,55}
|
|
)
|
|
for i=1,#channels do
|
|
local c = channels[i]
|
|
if c['id'] and c['name'] then
|
|
local e = get_epg_fct(c['id'])
|
|
if e then
|
|
table.insert(items,{
|
|
text=c['name']..format_epg(e),
|
|
action = function()
|
|
new_state(new_show_epgs_state(e,c))
|
|
end,
|
|
draw = draw_item,
|
|
einfo = e,
|
|
cinfo = c,
|
|
})
|
|
if sel_cidx == c.idx then
|
|
nstate.selected_item=#items
|
|
end
|
|
end
|
|
end
|
|
end
|
|
nstate.blue_name="Switch"
|
|
nstate.blue_action=function(self)
|
|
state_back_to("livetv")
|
|
switch_channel(items[self.selected_item].cinfo.idx)
|
|
end
|
|
nstate.yellow_name="Schedule"
|
|
nstate.yellow_action=function(self)
|
|
state_back()
|
|
new_state(create_epg_channel_schedule_menu_state(
|
|
items[self.selected_item].cinfo.idx))
|
|
end
|
|
if name=="epg_now" then
|
|
nstate.green_name="Next"
|
|
nstate.green_action=function(self)
|
|
state_back()
|
|
new_state(create_epg_now_next_menu_state("epg_next", get_epgnext,
|
|
items[self.selected_item].cinfo.idx))
|
|
end
|
|
else
|
|
nstate.green_name="Now"
|
|
nstate.green_action=function(self)
|
|
state_back()
|
|
new_state(create_epg_now_next_menu_state("epg_now", get_epgnow,
|
|
items[self.selected_item].cinfo.idx))
|
|
end
|
|
end
|
|
return nstate
|
|
end
|
|
|
|
local function playback_handle_key(self,key)
|
|
mp.log("info","state name "..self.name)
|
|
local temporarily_show_info = function()
|
|
mp.log("info","temp_show_info "..tostring(self.hide_osd_timeout))
|
|
if self.hide_osd_timeout~=nil or self.update_osd==nil then
|
|
self.hide_osd_timeout = config.show_info_timeout
|
|
self.update_osd = show_playback_info
|
|
update_hide_osd_timeout()
|
|
update_osd()
|
|
end
|
|
end
|
|
if key=="BLUE" then
|
|
state_back_to("livetv")
|
|
switch_channel(channel_idx)
|
|
elseif key=="BS" then
|
|
state_back()
|
|
switch_channel(channel_idx)
|
|
elseif key=="DOWN" or key=="UP" then
|
|
mp.command("cycle pause")
|
|
temporarily_show_info()
|
|
elseif key=="YELLOW" then
|
|
mp.command("no-osd seek +30")
|
|
temporarily_show_info()
|
|
elseif key=="MENU" then
|
|
state_main_menu.selected_item=1
|
|
new_state(state_main_menu)
|
|
elseif key=="GREEN" then
|
|
mp.command("no-osd seek -30")
|
|
temporarily_show_info()
|
|
elseif key=="ENTER" then
|
|
if self.update_osd==nil then
|
|
self.update_osd=show_playback_info
|
|
self.hide_osd_timeout=nil
|
|
else
|
|
self.update_osd=nil
|
|
end
|
|
update_osd()
|
|
end
|
|
end
|
|
|
|
function create_playback_state(rinfo)
|
|
local state_playback = {
|
|
name = "playback",
|
|
handle_key = playback_handle_key,
|
|
update_osd = nil,
|
|
rinfo = rinfo,
|
|
update_osd_timeout=1,
|
|
hide_osd_timeout = config.show_info_timeout,
|
|
update_osd = show_playback_info,
|
|
}
|
|
return state_playback
|
|
end
|
|
|
|
function read_info_file(self)
|
|
local file = io.open(self.info_file,"r")
|
|
if file then
|
|
local lines=file:read("*a")
|
|
local event={}
|
|
for v in lines:gmatch("[^\r\n]+") do
|
|
event = parse_event(event,v)
|
|
end
|
|
return event.description,format_epg(event),event.subtitle
|
|
else
|
|
mp.log("info","info file not found")
|
|
end
|
|
end
|
|
|
|
function check_for_vdr_recording(dir,name)
|
|
local rinfos={}
|
|
local dirname=utils.join_path(dir,name)
|
|
local dirs = utils.readdir(dirname,"dirs")
|
|
if dirs == nil then dirs={} end
|
|
for i,v in pairs(dirs) do
|
|
if ends_with(v,".rec") then
|
|
local rdir=utils.join_path(dirname,v)
|
|
local files = utils.readdir(rdir,"files")
|
|
local rinfo={url={},name=name}
|
|
if files == nil then files={} end
|
|
for j,w in pairs(files) do
|
|
if ends_with(w,".ts") then
|
|
table.insert(rinfo.url,utils.join_path(rdir,w))
|
|
elseif w:sub(1,1)=="0" and ends_with(w,".vdr") then
|
|
-- old recoding
|
|
table.insert(rinfo.url,utils.join_path(rdir,w))
|
|
elseif w=="info" or w=="info.vdr" then
|
|
rinfo.info_file=utils.join_path(rdir,w)
|
|
rinfo.info=read_info_file
|
|
end
|
|
end
|
|
if #rinfo.url>0 then
|
|
table.sort(rinfo.url)
|
|
table.insert(rinfos,rinfo)
|
|
end
|
|
end
|
|
end
|
|
return rinfos
|
|
end
|
|
|
|
local function show_info_action(self)
|
|
local item=self.items[self.selected_item]
|
|
local state={
|
|
name="Media Info",
|
|
update_osd=show_text,
|
|
text="No info",
|
|
message="Loading...",
|
|
handle_key=function()
|
|
state_back()
|
|
end,
|
|
}
|
|
mp.add_timeout(0.1,function()
|
|
if item==nil or item.rinfo==nil then
|
|
-- error?
|
|
elseif item.rinfo.info then
|
|
state.text,state.title,state.subtitle = item.rinfo:info()
|
|
elseif item.rinfo.url then
|
|
local file =io.open(item.rinfo.url:sub(1,-1-item.rinfo.ext:len())..".txt","r")
|
|
if file then
|
|
state.text=file:read("*a")
|
|
else
|
|
mp.log("info","No filename.txt file found")
|
|
end
|
|
end
|
|
state.message=nil
|
|
if state.text==nil then state.text="No Info" end
|
|
update_osd()
|
|
end)
|
|
new_state(state)
|
|
end
|
|
|
|
function create_show_media_state(dirname)
|
|
local update_items=function()
|
|
local items={}
|
|
local dirs = utils.readdir(dirname,"dirs")
|
|
if dirs == nil then dirs={} end
|
|
for i,v in pairs(dirs) do
|
|
local vpath=utils.join_path(dirname,v)
|
|
local rinfos = check_for_vdr_recording(dirname,v)
|
|
if #rinfos>0 then
|
|
for j,w in pairs(rinfos) do
|
|
table.insert(items, {
|
|
text=tostring(w.name),
|
|
rinfo=w,
|
|
action=function()
|
|
playback_recording(w)
|
|
new_state(create_playback_state(w))
|
|
end
|
|
})
|
|
end
|
|
else
|
|
table.insert(items,{
|
|
text=tostring(v),
|
|
action=function()
|
|
new_state( create_show_media_state(vpath))
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
local files=utils.readdir(dirname,"files")
|
|
if files == nil then files={} end
|
|
for i,v in pairs(files) do
|
|
V=v:upper()
|
|
for j,w in pairs(config.media_extensions) do
|
|
if ends_with(V,w) then
|
|
local rinfo={
|
|
name=tostring(v),
|
|
url=utils.join_path(dirname,v),
|
|
ext=w,
|
|
}
|
|
table.insert(items,{
|
|
text=tostring(v),
|
|
rinfo=rinfo,
|
|
action=function()
|
|
playback_recording(rinfo)
|
|
new_state(create_playback_state(rinfo))
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
return items
|
|
end
|
|
local state=new_menu_state("Media",update_items)
|
|
state.blue_name="Info"
|
|
state.blue_action=show_info_action
|
|
return state
|
|
end
|
|
|
|
function create_recordings_show_items(recordings)
|
|
items={}
|
|
for i,r in pairs(recordings) do
|
|
if r['name'] ~= nil then
|
|
local text=r['title']
|
|
if r['time'] then text = r['time'].." "..text end
|
|
if r['day'] then text = r['day'].." "..text end
|
|
table.insert(items,{
|
|
text = text,
|
|
action = function(self)
|
|
if #self.rinfo >0 then
|
|
new_state( new_menu_state("Recordings",
|
|
create_recordings_show_items(self.rinfo)
|
|
))
|
|
else
|
|
playback_recording(self.rinfo)
|
|
new_state(create_playback_state(self.rinfo))
|
|
end
|
|
end,
|
|
rinfo = r,
|
|
})
|
|
end
|
|
end
|
|
return items
|
|
end
|
|
|
|
function create_timers_show_items(timers)
|
|
items={}
|
|
local draw_item=draw_column_item(
|
|
{'tinfo.enabled_str','tinfo.chno','tinfo.day_str','tinfo.start_str','tinfo.stop_str','tinfo.name'},
|
|
{20,30,70,50,50})
|
|
for i,r in pairs(timers) do
|
|
table.insert(items,{
|
|
tinfo = r,
|
|
draw = draw_item,
|
|
action = function(self)
|
|
new_state(create_edit_timer_menu_state(self.tinfo))
|
|
end,
|
|
})
|
|
end
|
|
return items
|
|
end
|
|
|
|
-- ************************* Remote OSD ***********************
|
|
|
|
local vdr_keys= {
|
|
UP="Up", DOWN="Down", LEFT="Left", RIGHT="Right",
|
|
BS="Back", RED="Red", GREEN="Green", YELLOW="Yellow", BLUE="Blue",
|
|
ENTER="Ok", m="MENU",
|
|
}
|
|
|
|
function update_remote_osd(self)
|
|
self.osdinfo=parse_svdrposd_lsto(send_svdrp("PLUG svdrposd LSTO"))
|
|
self.items=self.osdinfo.items
|
|
self.draw_item=draw_tabbed_column_item
|
|
if self.osdinfo.text then
|
|
self.text=self.osdinfo.text:gsub("|","\n")
|
|
else
|
|
self.text=""
|
|
end
|
|
self.selected_item=self.osdinfo.selected
|
|
self.red_name=self.osdinfo.red
|
|
self.green_name=self.osdinfo.green
|
|
self.yellow_name=self.osdinfo.yellow
|
|
self.blue_name=self.osdinfo.blue
|
|
self.header="Remote OSD: "..tostring(self.osdinfo.title)
|
|
mp.log("info","remote osd red: ".. tostring(self.red_name))
|
|
|
|
if self.items and #self.items>0 then
|
|
self.update_osd=show_menu
|
|
else
|
|
self.update_osd=show_text
|
|
end
|
|
|
|
self.message=nil
|
|
update_osd()
|
|
end
|
|
|
|
function remote_osd_handle_key(self,k)
|
|
mp.log("info","remote osd key "..k)
|
|
mp.log("info","osdinfo "..tostring(self.osdinfo.open))
|
|
if k=="BS" and self.osdinfo.open==false then
|
|
state_back()
|
|
elseif vdr_keys[k] ~= nil then
|
|
mp.log("info","sending key")
|
|
self.message="Updating..."
|
|
update_osd()
|
|
send_svdrp("HITK "..vdr_keys[k])
|
|
update_remote_osd(self)
|
|
end
|
|
end
|
|
|
|
function create_remote_osd_menu_state()
|
|
local state_menu = {
|
|
name = "remote_osd",
|
|
handle_key = remote_osd_handle_key,
|
|
update_osd = show_menu,
|
|
items = {},
|
|
osdinfo = {
|
|
open = false,
|
|
},
|
|
message = "Loading..",
|
|
}
|
|
mp.add_timeout(0.1,function()
|
|
update_remote_osd(state_menu)
|
|
end)
|
|
return state_menu
|
|
end
|
|
|
|
-- ************************* Menu Stuff ***********************
|
|
|
|
function new_menu_state(name,items)
|
|
local state_menu = {
|
|
name = name,
|
|
handle_key = menu_handle_key,
|
|
update_osd = show_menu,
|
|
}
|
|
if type(items) == "function" then
|
|
state_menu.message="Loading..."
|
|
mp.add_timeout(0.1, function()
|
|
state_menu.items=items()
|
|
state_menu.message=nil
|
|
update_osd()
|
|
end)
|
|
else
|
|
state_menu.items=items
|
|
end
|
|
return state_menu
|
|
end
|
|
|
|
function create_edit_timer_menu_state(timer)
|
|
local update_items=function()
|
|
local items={
|
|
{ text="Active\t: "..(timer.enabled==0 and "no" or "yes"), },
|
|
{ text="Channel\t: "..tostring(timer.chno).." "..tostring(channel_info_from_cid(timer.cid).name),},
|
|
{ text="Day\t: "..timer.day},
|
|
{ text="Start\t: "..timer.start:sub(1,2)..":"..timer.start:sub(3,4),},
|
|
{ text="Stop\t: "..timer.stop:sub(1,2)..":"..timer.stop:sub(3,4),},
|
|
{ text="Priority\t: "..timer.priority,},
|
|
{ text="Lifetime\t: "..timer.lifetime,},
|
|
{ text="File\t: "..timer.name,},
|
|
}
|
|
return items
|
|
end
|
|
|
|
local timer_menu_state=new_menu_state("Show Timer", update_items)
|
|
timer_menu_state.column_width={80}
|
|
timer_menu_state.red_name="On/Off"
|
|
timer_menu_state.red_action=function(self)
|
|
timer_menu_state.message="Updating timer..."
|
|
update_osd()
|
|
toggle_timer_onoff(timer)
|
|
send_update_timer(timer)
|
|
load_timers()
|
|
match_timer_to_event(timerinfo[cid],epginfo[cid])
|
|
self.items=update_items()
|
|
timer_menu_state.message=nil
|
|
update_osd()
|
|
end
|
|
return timer_menu_state
|
|
end
|
|
|
|
function confirm_action(msg,action)
|
|
return function(self)
|
|
self.confirm=msg
|
|
self.confirm_action=action
|
|
update_osd()
|
|
end
|
|
end
|
|
|
|
function create_timer_menu_state()
|
|
local update_items= function()
|
|
local timers=load_timers();
|
|
return create_timers_show_items(timers)
|
|
end
|
|
local timer_menu_state=new_menu_state("Timers", update_items)
|
|
|
|
timer_menu_state.red_name="On/Off"
|
|
timer_menu_state.red_action=function(self)
|
|
timer_menu_state.message="Updating timer..."
|
|
update_osd()
|
|
local timer=self.items[self.selected_item].tinfo
|
|
toggle_timer_onoff(timer)
|
|
local ret = send_update_timer(timer)
|
|
if ret then
|
|
timer_menu_state.confrim="Error: "..tostring(ret)
|
|
timer_menu_state.confirm_action=function() end
|
|
end
|
|
self.items=update_items()
|
|
timer_menu_state.message=nil
|
|
update_osd()
|
|
end
|
|
timer_menu_state.yellow_name="Delete"
|
|
timer_menu_state.yellow_action=confirm_action("Are you sure? Press OK to delete",function(self)
|
|
timer_menu_state.message="Deleting timer..."
|
|
update_osd()
|
|
local ret=send_delete_timer(self.items[self.selected_item].tinfo)
|
|
if ret then
|
|
timer_menu_state.confrim="Error: "..tostring(ret)
|
|
timer_menu_state.confirm_action=function() end
|
|
end
|
|
self.items=update_items()
|
|
timer_menu_state.message=nil
|
|
update_osd()
|
|
end)
|
|
timer_menu_state.blue_name="Info"
|
|
timer_menu_state.blue_action=function(self)
|
|
timer_menu_state.message="Loading..."
|
|
update_osd()
|
|
local timer=self.items[self.selected_item].tinfo
|
|
load_epg_channel(timer.cid)
|
|
local state=new_show_epgs_state(timer.event,
|
|
channel_info_from_cid(timer.cid))
|
|
timer_menu_state.message=nil
|
|
new_state(state)
|
|
end
|
|
return timer_menu_state
|
|
end
|
|
|
|
function init_main_menu()
|
|
main_menu_items=
|
|
{
|
|
{
|
|
text="Schedule",
|
|
action = function()
|
|
local nstate=create_epg_channel_schedule_menu_state(channel_idx)
|
|
new_state(nstate)
|
|
end,
|
|
},
|
|
{
|
|
text="Timers",
|
|
action = function()
|
|
new_state(create_timer_menu_state())
|
|
end,
|
|
},
|
|
}
|
|
if config.vdr_video_dir:len()==0 then
|
|
-- use streamdev for recordings
|
|
table.insert( main_menu_items, #main_menu_items+1, {
|
|
text="Recordings",
|
|
action = function()
|
|
local update_items=function(self)
|
|
--local recordings=parse_lstr(send_svdrp("lstr"))
|
|
local recordings=parse_ext3mu(send_webrequest("/recordings.m3u"))
|
|
recordings = collect_directories(recordings)
|
|
return create_recordings_show_items(recordings)
|
|
end
|
|
local state=new_menu_state("Recordings", update_items)
|
|
-- state.blue_name="Info"
|
|
-- state.blue_action=show_info_action
|
|
-- state.yellow_name="Remove"
|
|
-- state.yellow_action=confirm_action("Are you sure? Press OK to remove",
|
|
-- function(self)
|
|
-- local item=self.items[self.selected_item]
|
|
-- self.message="Deleting recording..."
|
|
-- update_osd()
|
|
-- local error_msg=check_for_errors(send_svdrp(
|
|
-- string.format("DELR %d",item.rinfo.idx)))
|
|
-- if error_msg then
|
|
-- self.confirm="Error: "..error_msg
|
|
-- self.confirm_action=function() end
|
|
-- end
|
|
-- self.items=update_items()
|
|
-- self.message=nil
|
|
-- self:update_state()
|
|
-- update_osd()
|
|
-- end)
|
|
state.update_state = update_state_disk_header
|
|
new_state(state)
|
|
end,
|
|
})
|
|
else
|
|
-- vdr video dir is locally mounted, read it directly
|
|
table.insert( main_menu_items, #main_menu_items+1, {
|
|
text="Recordings",
|
|
action = function()
|
|
new_state( create_show_media_state(config.vdr_video_dir) )
|
|
end
|
|
})
|
|
end
|
|
|
|
if config.media_dir:len()>0 then
|
|
table.insert( main_menu_items,#main_menu_items+1,{
|
|
text="Media",
|
|
action = function()
|
|
new_state( create_show_media_state(config.media_dir) )
|
|
end,
|
|
})
|
|
end
|
|
state_main_menu = new_menu_state("main_menu", main_menu_items)
|
|
state_main_menu.update_state = update_state_disk_header
|
|
|
|
state_livetv = {
|
|
name = "livetv",
|
|
handle_key = livetv_handle_key,
|
|
update_osd = nil,
|
|
}
|
|
|
|
|
|
state_channel_info = {
|
|
name = "channel_info",
|
|
handle_key = livetv_handle_key,
|
|
update_osd = show_channel_info,
|
|
timeout = 5,
|
|
}
|
|
end
|
|
|
|
function channel_str_to_chidx(channel_str)
|
|
local chidx
|
|
if channel_str then
|
|
chidx=tonumber(channel_str)
|
|
mp.log("info","1 startup_channel "..tostring(chidx))
|
|
if #channels>0 and chidx then
|
|
-- translate channel number to channel idx
|
|
chidx=chno_to_idx[chidx]
|
|
end
|
|
end
|
|
if (chidx== nil and #channels>0 and channel_str and channel_str:len()>1) then
|
|
-- channel given as channel id
|
|
chidx=chid_to_idx[channel_str]
|
|
end
|
|
return chidx
|
|
end
|
|
|
|
function do_startup(url)
|
|
init_main_menu()
|
|
|
|
mp.add_key_binding("F1",'vdrkeyRED',key("RED"))
|
|
mp.add_key_binding("F2",'vdrkeyGREEN',key("GREEN"))
|
|
mp.add_key_binding("F3",'vdrkeyYELLOW',key("YELLOW"))
|
|
mp.add_key_binding("F4",'vdrkeyBLUE',key("BLUE"))
|
|
mp.add_key_binding("0",'vdrkey0',key(0))
|
|
mp.add_key_binding("1",'vdrkey1',key(1))
|
|
mp.add_key_binding("2",'vdrkey2',key(2))
|
|
mp.add_key_binding("3",'vdrkey3',key(3))
|
|
mp.add_key_binding("4",'vdrkey4',key(4))
|
|
mp.add_key_binding("5",'vdrkey5',key(5))
|
|
mp.add_key_binding("6",'vdrkey6',key(6))
|
|
mp.add_key_binding("7",'vdrkey7',key(7))
|
|
mp.add_key_binding("8",'vdrkey8',key(8))
|
|
mp.add_key_binding("9",'vdrkey9',key(9))
|
|
mp.add_key_binding("UP",'vdrkeyUP',key("UP"),{repeatable=true})
|
|
mp.add_key_binding("DOWN",'vdrkeyDOWN',key("DOWN"),{repeatable=true})
|
|
mp.add_key_binding("LEFT",'vdrkeyLEFT',key("LEFT"),{repeatable=true})
|
|
mp.add_key_binding("RIGHT",'vdrkeyRIGHT',key("RIGHT"),{repeatable=true})
|
|
mp.add_key_binding("ENTER",'vdrkeyENTER',key("ENTER"))
|
|
mp.add_key_binding("BS",'vdrkeyBACK',key("BS"))
|
|
mp.add_key_binding("m",'vdrkeyMENU',key("MENU"))
|
|
|
|
local host,port,channel=url:match("vdrstream://([^:/]*)(:?[%d]*)(/?.*)")
|
|
if host and host:len()>0 then
|
|
config.host=host
|
|
end
|
|
if port and port:len()>1 then
|
|
config.streamdev_port=tonumber(port:sub(2))
|
|
end
|
|
mp.log("info","VDR host:"..config.host)
|
|
mp.log("info","VDR svdrp port:"..config.svdrp_port)
|
|
mp.log("info","VDR streamdev port:"..config.streamdev_port)
|
|
vdruri="http://"..config.host..":"..config.streamdev_port.."/TS/"
|
|
|
|
-- set parameters to optimize channel switch time
|
|
--mp.set_property("cache-secs",1)
|
|
mp.set_property("demuxer-lavf-analyzeduration",1)
|
|
mp.set_property("ytdl","no")
|
|
mp.set_property("keep-open","yes")
|
|
mp.set_property("idle","yes")
|
|
mp.set_property("prefetch-playlist","yes")
|
|
mp.set_property("force-window","yes")
|
|
|
|
get_channels()
|
|
channel=channel:sub(2)
|
|
channel_idx=channel_str_to_chidx(channel)
|
|
if channel_idx==nil then
|
|
channel_idx=channel_str_to_chidx(config.startup_channel)
|
|
end
|
|
if channel_idx==nil then
|
|
channel_idx=1
|
|
end
|
|
-- load epg in background
|
|
mp.add_timeout(1,function()
|
|
load_timers()
|
|
load_epg_now()
|
|
load_epg_next()
|
|
match_nownext_timer_to_event()
|
|
mp.log("info","finished epg")
|
|
update_osd()
|
|
check_for_plugins()
|
|
end)
|
|
-- periodically update epg
|
|
epg_timer = mp.add_periodic_timer(config.epg_nownext_update_time,function()
|
|
load_timers()
|
|
-- only update "next" event, old "next" events become "now" events
|
|
load_epg_next()
|
|
match_nownext_timer_to_event()
|
|
end)
|
|
|
|
new_state( state_livetv )
|
|
end
|
|
|
|
mp.add_hook("on_load", 50, on_start)
|