diff options
Diffstat (limited to '.config/mpv/scripts/interactive-video.lua')
| -rw-r--r-- | .config/mpv/scripts/interactive-video.lua | 905 |
1 files changed, 905 insertions, 0 deletions
diff --git a/.config/mpv/scripts/interactive-video.lua b/.config/mpv/scripts/interactive-video.lua new file mode 100644 index 0000000..dff046a --- /dev/null +++ b/.config/mpv/scripts/interactive-video.lua @@ -0,0 +1,905 @@ +local utils = require "mp.utils" +local msg = require "mp.msg" + + +--[[ Utility functions ]]------------------------------------------------------ + +-- Change this to `msg.info' to see debug messages on mpv output. +local msg_debug = msg.debug + +-- Count elements in a table. +function count(tbl) + local n = 0 + for _ in pairs(tbl) do n = n + 1 end + return n +end + +-- Make a copy a table (but not of its elements). +function shallow_copy(orig) + local copy + if type(orig) == "table" then + copy = {} + for key, val in pairs(orig) do + copy[key] = val + end + else + copy = orig + end + return copy +end + +-- Round to nearest integer. +math.round = function(x) + return math.floor(x + 0.5) +end + + +--[[ Time functions ]]--------------------------------------------------------- + +-- Only used for rounding purposes: having the exact value is not necessary. +-- Default to 25fps (i.e., 40ms). +local frame_duration = 40 + +-- Get frame duration from container-fps property. +function update_frame_duration() + local fps = mp.get_property_number("container-fps") or 25 + frame_duration = 1000 / (fps > 0 and fps or 25) +end +mp.register_event("file-loaded", update_frame_duration) + +-- Round time position (in ms) to a multiple of frame_duration. +function round_to_frame(time) + return math.round(math.round(time / frame_duration) * frame_duration) +end + +-- Time position of previous frame. +function prev_frame(time) + return round_to_frame(time - frame_duration) +end + +-- Format time position (in ms) as hh:mm:ss.msc. +function time_to_string(time) + return string.format("%02d:%02d:%06.3f", + math.floor(time / 3600000), + math.floor(time / 60000) % 60, + (time % 60000) / 1000) +end + +-- Retrieve the time-pos property (in ms) and round it to a frame position. +function get_time_pos() + local t = (mp.get_property_number("time-pos") or 0) * 1000 - frame_duration + return round_to_frame(t) +end + +-- Seek playback to given time position (in ms). +function set_time_pos(time) + msg_debug("seek to: " .. time_to_string(time)) + local t = round_to_frame(time + frame_duration) / 1000 + mp.set_property_number("time-pos", t) +end + +-- Retrieve the duration property (in ms) and round it to a frame position. +function get_duration() + local t = (mp.get_property_number("duration") or 0) * 1000 - frame_duration + return round_to_frame(t) +end + + +--[[ Global data and state variables ]]---------------------------------------- + +local initial_segment, segments, moments, preconditions, segment_groups +local state = { active = false } + + +--[[ Apply impression ]]------------------------------------------------------- + +function apply_impression(impression) + if impression == nil then + return + + elseif impression.type == "userState" then + for var, val in pairs(impression.data.persistent or {}) do + msg_debug("set variable: " .. var .. " = " .. + utils.to_string(val) .. " (was: " .. + utils.to_string(state.vars[var]) .. ")") + state.vars[var] = val + end + + else + msg.error("Invalid type of impression data: " .. + utils.to_string(impression.type)) + end +end + + +--[[ Evaluate precondition ]]-------------------------------------------------- + +function eval_precondition(cond) + if cond == nil then + return true + + elseif type(cond) ~= "table" then + return cond + + elseif #cond == 0 then + msg.error("Empty precondition expression") + + elseif cond[1] == "not" and #cond == 2 then + return not eval_precondition(cond[2]) + + elseif cond[1] == "and" then + for i = 2, #cond do + if not eval_precondition(cond[i]) then return false end + end + return true + + elseif cond[1] == "or" then + for i = 2, #cond do + if eval_precondition(cond[i]) then return true end + end + return false + + elseif cond[1] == "eql" and #cond == 3 then + return eval_precondition(cond[2]) == eval_precondition(cond[3]) + + elseif cond[1] == "persistentState" and #cond == 2 then + return state.vars[cond[2]] + + else + msg.error("Invalid precondition: " .. utils.to_string(cond)) + end + + return false +end + + +--[[ Format strings for displaying choices on OSD ]]--------------------------- + +function format_osd_choices(choices) + local osd_choices = {} + for i = 1, #choices do + local str = "" + for j, ch in ipairs(choices) do + local b = i == j + str = str .. "{\\fscx70\\fscy70\\an5" + .. "\\pos(" .. ((2*j-1) / (2*#choices)) .. ",0.048)}" + .. (i == j and "{\\c&HFFFFFF&}[ " or "{\\c&H7F7F7F&}") + .. ch.text + .. (i == j and " ]" or "") + .. "\n" + end + table.insert(osd_choices, str) + end + return osd_choices +end + + +--[[ Update OSD according to current state ]]---------------------------------- + +function update_osd() + -- Multiple-choice input. + if state.osd_choices and type(state.osd_input) == "number" then + mp.set_osd_ass(1, 1, state.osd_choices[state.osd_input]) + + -- Code entry input. + elseif state.osd_prompt and type(state.osd_input) == "string" then + mp.set_osd_ass(1, 1, "{\\fscx70\\fscy70\\an4\\pos(0.02,0.048)}" .. + state.osd_prompt .. " " .. state.osd_input .. "_\n") + + -- Nothing to display. + else + mp.set_osd_ass(0, 0, "") + end +end + + +--[[ Navigation and input control functions ]]--------------------------------- + +-- Dummy function. +function cmd_nop() +end + +-- Seek forward. +function cmd_fwd(sec, skip) + return function() + process_events(get_time_pos() + sec * 1000, { no_skip = not skip, + ffwd = true }) + end +end + +-- Seek backward. +function cmd_bwd(sec, skip) + return function() + rewind(sec * 1000, { no_skip = not skip }) + end +end + +-- Select next choice. +function cmd_input_next() + if state.osd_input < #state.osd_choices then + state.osd_input = state.osd_input + 1 + else + state.osd_input = 1 + end + update_osd() +end + +-- Select previous choice. +function cmd_input_prev() + if state.osd_input > 1 then + state.osd_input = state.osd_input - 1 + else + state.osd_input = #state.osd_choices + end + update_osd() +end + +-- Input character. +function cmd_input_char(char) + return function() + state.osd_input = state.osd_input .. char + update_osd() + end +end + +-- Delete last input character. +function cmd_input_backspace() + if string.len(state.osd_input) > 0 then + state.osd_input = string.sub(state.osd_input, 1, -2) + update_osd() + end +end + +-- Submit current input. +function cmd_input_submit() + state.osd_choices = nil + state.osd_prompt = nil + table.insert(state.events, 1, { time = get_time_pos(), type = "submit", + mom_id = state.osd_mom_id }) + update_osd() + update_controls() +end + + +--[[ Key mappings for control functions ]]------------------------------------- + +-- Merge key mappings. +-- Mappings in map1 take precedence over those in map2. +function mapping_merge(map1, map2) + for key, ctrl in pairs(map2) do + map1[key] = map1[key] or ctrl + end +end + +-- Key mapping for navigation. +local nav_mapping = { + ["RIGHT"] = { "iv-nav-right", cmd_fwd( 10), {repeatable=true} }, + ["SHIFT+RIGHT"] = { "iv-nav-sright", cmd_fwd( 10,true), {repeatable=true} }, + ["LEFT"] = { "iv-nav-left", cmd_bwd( 10), {repeatable=true} }, + ["SHIFT+LEFT"] = { "iv-nav-sleft", cmd_bwd( 10,true), {repeatable=true} }, + ["UP"] = { "iv-nav-up", cmd_fwd( 60), {repeatable=true} }, + ["SHIFT+UP"] = { "iv-nav-sup", cmd_fwd( 60,true), {repeatable=true} }, + ["DOWN"] = { "iv-nav-down", cmd_bwd( 60), {repeatable=true} }, + ["SHIFT+DOWN"] = { "iv-nav-sdown", cmd_bwd( 60,true), {repeatable=true} }, + ["PGUP"] = { "iv-nav-pgup", cmd_fwd(1/0), {repeatable=true} }, + ["SHIFT+PGUP"] = { "iv-nav-spgup", cmd_fwd(600,true), {repeatable=true} }, + ["PGDWN"] = { "iv-nav-pgdwn", cmd_bwd(600), {repeatable=true} }, + ["SHIFT+PGDWN"] = { "iv-nav-spgdwn", cmd_bwd(600,true), {repeatable=true} }, +} + +-- Control mapping for multiple-choice input. +local input_choice_mapping = { + ["RIGHT"] = { "iv-input-right", cmd_input_next, { repeatable = true } }, + ["LEFT"] = { "iv-input-left", cmd_input_prev, { repeatable = true } }, + ["ENTER"] = { "iv-input-enter", cmd_input_submit }, +} +for _, key in ipairs({ "UP", "DOWN", "PGUP", "PGDWN" }) do + input_choice_mapping[key] = { "iv-nop-"..key, cmd_nop } +end +mapping_merge(input_choice_mapping, nav_mapping) + +-- Control mapping for code entry input. +local input_code_mapping = { + ["BS"] = { "iv-input-bs", cmd_input_backspace, { repeatable = true } }, + ["ENTER"] = { "iv-input-enter", cmd_input_submit }, +} +for _, key in ipairs({ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" }) do + input_code_mapping[key] = { "iv-input-" ..key, cmd_input_char(key) } + input_code_mapping["KP"..key] = { "iv-input-kp"..key, cmd_input_char(key) } +end +for _, key in ipairs({ "RIGHT", "LEFT", "UP", "DOWN", "PGUP", "PGDWN" }) do + input_code_mapping[key] = { "iv-nop-" ..key, cmd_nop } +end +mapping_merge(input_code_mapping, nav_mapping) + + +--[[ Update controls according to current state ]]----------------------------- + +local current_mapping + +function update_controls() + local new_mapping + + if state.active then + -- Multiple-choice input. + if state.osd_choices and type(state.osd_input) == "number" then + new_mapping = input_choice_mapping + + -- Code entry input. + elseif state.osd_prompt and type(state.osd_input) == "string" then + new_mapping = input_code_mapping + + -- No input: only navigation controls. + else + new_mapping = nav_mapping + end + end + + if new_mapping ~= current_mapping then + -- Remove current control bindings. + for key, ctrl in pairs(current_mapping or {}) do + mp.remove_key_binding(ctrl[1]) + end + + -- Register new control bindings. + current_mapping = new_mapping + for key, ctrl in pairs(current_mapping or {}) do + mp.add_forced_key_binding(key, table.unpack(ctrl)) + end + end +end + + +--[[ Deactivate interactive video playback ]]---------------------------------- + +function deactivate() + mp.unregister_event(on_tick) + state = { active = false } + update_osd() + update_controls() +end + + +--[[ Retrieve first valid segment from segment group ]]------------------------ + +function resolve_segment_group(group_id) + for _, seg_id in ipairs(segment_groups[group_id] or {}) do + if type(seg_id) == "table" and seg_id.segmentGroup then + seg_id = resolve_segment_group(seg_id.segmentGroup) + if seg_id then return seg_id end + else + local cond_id = seg_id + if type(seg_id) == "table" then + cond_id = seg_id.precondition + seg_id = seg_id.segment + end + if eval_precondition(preconditions[cond_id]) then + return seg_id + end + end + end + return nil +end + + +--[[ Load segment and schedule all related events in the event queue ]]-------- + +function load_segment(seg_id) + msg_debug("load segment: " .. seg_id) + state.seg_id = seg_id + + state.events = {} + + -- Add moment-related events. + for i, mom in ipairs(moments[state.seg_id] or {}) do + table.insert(state.events, { time = mom.startMs, + type = "start", mom_id = i }) + table.insert(state.events, { time = prev_frame(mom.endMs), + type = "end", mom_id = i }) + if string.sub(mom.type, 1, 6) == "scene:" then + table.insert(state.events, { time = mom.uiDisplayMS, + type = "display", mom_id = i }) + table.insert(state.events, { time = prev_frame(mom.uiHideMS), + type = "hide", mom_id = i }) + end + end + + -- Sort moment-related events. + table.sort(state.events, function(ev1, ev2) + if ev1.time ~= ev2.time or ev1.mom_id ~= ev2.mom_id then + return ev1.time < ev2.time + elseif ev1.type ~= ev2.type then + return ev1.type == "start" or ev2.type == "end" or + (ev1.type == "display" and ev2.type == "hide") + else + return false + end + end) + + -- Add segment start and end events. + local seg = segments[state.seg_id] + table.insert(state.events, 1, { time = seg.startTimeMs, + type = "start_seg" }) + table.insert(state.events, { time = prev_frame(seg.endTimeMs or + get_duration()), + type = "end_seg" }) +end + + +--[[ Process all pending events until given (or current) time position ]]------ + +function process_events(time, flags) + time = time or get_time_pos() + flags = flags or {} + + local seek = flags.ffwd + + if not state.events then return end + while #state.events > 0 and time >= state.events[1].time do + -- Pop first event from queue. + local ev = state.events[1] + table.remove(state.events, 1) + + msg_debug("process event: " .. time_to_string(ev.time) .. " " .. + string.format("%-10s", ev.type) .. + state.seg_id .. (ev.mom_id and ("/" .. ev.mom_id) or "") .. + ((ev.type == "submit" or ev.type == "end") and state.osd_input + and (" (" .. utils.to_string(state.osd_input) .. ")") or "")) + + local next_seg_id = nil + + -- Moment-related event? + if ev.mom_id then + local mom = moments[state.seg_id][ev.mom_id] + + -- Start of new moment? + if ev.type == "start" then + -- Check precondition, and remove all moments related to this event + -- if it is not satisfied. + if not eval_precondition(mom.precondition) then + for i = #state.events, 1, -1 do + if state.events[i].mom_id == ev.mom_id then + table.remove(state.events, i) + end + end + else + apply_impression(mom.impressionData) + end + + -- Scene-related event? + elseif string.sub(mom.type, 1, 6) == "scene:" then + -- Display user input controls. + if ev.type == "display" then + state.osd_mom_id = ev.mom_id + if mom.config.hasMultipleChoiceInput then + state.osd_prompt = "Enter code:" + state.osd_input = "" + else + state.osd_choices = format_osd_choices(mom.choices) + state.osd_input = mom.defaultChoiceIndex + 1 + end + if state.hist[state.hist_idx].inputs[ev.mom_id] then + state.osd_input = state.hist[state.hist_idx].inputs[ev.mom_id] + end + if flags.no_skip and time > ev.time then + time = ev.time + seek = true + end + + -- Hide user input controls. + elseif ev.type == "hide" then + state.osd_choices = nil + state.osd_prompt = nil + state.osd_mom_id = nil + + -- Select branch according to user input. + elseif ev.type == "end" or + (ev.type == "submit" and + not mom.config.disableImmediateSceneTransition) then + -- Record input in history. + -- Clear all forward history if input different from recorded one. + local hist = state.hist[state.hist_idx] + if state.osd_input ~= hist.inputs[ev.mom_id] then + hist.inputs[ev.mom_id] = state.osd_input + for i, mi in ipairs(moments[state.seg_id]) do + if string.sub(mi.type, 1, 6) == "scene:" and + mi.startMs >= mom.endMs then + hist.inputs[i] = nil + end + end + for i = #state.hist, state.hist_idx+1, -1 do + state.hist[i] = nil + end + end + + -- Find corresponding choice. + local choice + if mom.config.hasMultipleChoiceInput then + for _, ch in ipairs(mom.choices) do + if not ch.code or state.osd_input == ch.code then + choice = ch + break + end + end + if not choice then + msg.error("No choice available for input '" .. state.osd_input .. + "' in moment " .. state.seg_id .. "/" .. ev.mom_id) + deactivate() + return + end + else + choice = mom.choices[state.osd_input] + end + apply_impression(choice.impressionData) + + -- Select next segment accordingly. + if not (mom.trackingInfo and + mom.trackingInfo.optionType == "fakeOption") then + next_seg_id = choice.segmentId or resolve_segment_group(choice.sg) + if not next_seg_id then + msg.error("No segment for choice '" .. choice.id .. "' " .. + "of moment " .. state.seg_id .. "/" .. ev.mom_id) + deactivate() + return + end + end + state.osd_input = nil + end + end + + -- Start of current segment? + elseif ev.type == "start_seg" then + state.hist_idx = state.hist_idx + 1 + if not state.hist[state.hist_idx] then + state.hist[state.hist_idx] = { seg_id = state.seg_id, + vars = shallow_copy(state.vars), + inputs = {} } + end + + -- End of current segment? + elseif ev.type == "end_seg" then + next_seg_id = resolve_segment_group(state.seg_id) or + next(segments[state.seg_id].next) + if not next_seg_id then + msg.debug("No segment after " .. state.seg_id .. "; " .. + "assuming end of video") + deactivate() + mp.commandv("playlist-next", "force") + return + end + end + + -- Load next segment? + if next_seg_id then + local cur_seg = segments[state.seg_id] + local next_seg = segments[next_seg_id] + + -- If next segment does not directly follow current segment, + -- we need to jump. + if next_seg.startTimeMs ~= cur_seg.endTimeMs then + if flags.ffwd then + time = next_seg.startTimeMs + time - prev_frame(cur_seg.endTimeMs) + else + time = next_seg.startTimeMs + end + seek = true + + -- Also jump if skipping end of current segment. + elseif time < next_seg.startTimeMs then + time = next_seg.startTimeMs + seek = true + end + + load_segment(next_seg_id) + end + end + + -- Jump to current time position, if required. + if seek then + set_time_pos(time) + end + + -- Update OSD and controls according to current state. + update_osd() + update_controls() +end + + +--[[ Seek backwards and rewind history ]]-------------------------------------- + +function rewind(delay, flags) + flags = flags or {} + + if state.hist_idx == 0 then return end + + local time = get_time_pos() + local seg_id = state.hist[state.hist_idx].seg_id + local first = true + + -- Keep rewinding from segment to segment until delay is consumed. + while delay > 0 and (first or state.hist_idx > 1) do + if first then + first = false + else + state.hist_idx = state.hist_idx - 1 + seg_id = state.hist[state.hist_idx].seg_id + time = segments[seg_id].endTimeMs + end + + -- If in no-skip mode, find previous scene, if any. + if flags.no_skip then + local prev_mom + for _, mom in ipairs(moments[seg_id]) do + if string.sub(mom.type, 1, 6) == "scene:" and + time - delay <= mom.uiDisplayMS and mom.uiDisplayMS < time and + (not prev_mom or prev_mom.uiDisplayMS < mom.uiDisplayMS) then + prev_mom = mom + end + end + if prev_mom then + time = prev_mom.uiDisplayMS + delay = 0 + break + end + end + + -- Rewind until start of current segment. + delay = delay - time + segments[seg_id].startTimeMs + time = segments[seg_id].startTimeMs + end + + -- Adjust actual time. + if delay < 0 then + time = time - delay + end + + -- Load current segment and state variables from history. + load_segment(seg_id) + shallow_copy(state.vars, state.hist[state.hist_idx].vars) + state.hist_idx = state.hist_idx - 1 + state.osd_choices = nil + state.osd_prompt = nil + + -- Re-run current segment's history forward until actual time. + process_events(time, { ffwd = true }) +end + + +--[[ Load and check JSON data files, if any, on file load ]]------------------- + +function on_start_file(_) + deactivate() + + -- Look for JSON data files. + + local dir = utils.split_path(mp.get_property("path")) + local base = mp.get_property("filename/no-ext") + local seg = utils.join_path(dir, base .. ".seg.json") + local ivm = utils.join_path(dir, base .. ".ivm.json") + if not (utils.file_info(seg) and utils.file_info(ivm)) then + return + end + msg.info("Found JSON data files for interactive video playback:\n" .. + " seg: " .. seg .. "\n" .. + " ivm: " .. ivm) + + -- Read and parse JSON data files. + + local file + file = io.open(seg, "r") + if not file then + msg.error("Cannot read from " .. seg) + return + end + seg = utils.parse_json(file:read("*a")) + file:close() + + file = io.open(ivm, "r") + if not file then + msg.error("Cannot read from " .. ivm) + return + end + ivm = utils.parse_json(file:read("*a")) + file:close() + + -- Initialize data from JSON structures. + + segments = seg.segments + initial_segment = seg.initialSegment + local video_id = "" .. (seg.viewableId or "") + + if not segments then + msg.error( "segments not found in JSON data files") + return + elseif not initial_segment then + msg.error("initialSegment not found in JSON data files") + return + elseif not video_id then + msg.error( "viewableId not found in JSON data files") + return + end + + if ivm.videos and ivm.videos[video_id] and + ivm.videos[video_id].interactiveVideoMoments then + ivm = ivm.videos[video_id].interactiveVideoMoments.value + else + ivm = nil + end + if not ivm then + msg.error("interactiveVideoMoments not found in JSON data files") + return + end + + moments = ivm.momentsBySegment + preconditions = ivm.preconditions + segment_groups = ivm.segmentGroups + state.vars = shallow_copy(ivm.stateHistory) + + if not moments then + msg.error("momentsBySegment not found in JSON data files") + return + elseif not preconditions then + msg.error( "preconditions not found in JSON data files") + return + elseif not segment_groups then + msg.error( "segmentGroups not found in JSON data files") + return + elseif not state.vars then + msg.error( "stateHistory not found in JSON data files") + return + end + + -- Sanity checks. + + local fail = false + + -- Check segment history. + if not (ivm.segmentHistory and #ivm.segmentHistory == 1 and + ivm.segmentHistory[1] == initial_segment) then + msg.error("Invalid segmentHistory" .. + ": expected " .. utils.to_string({ initial_segment }) .. + ", got " .. utils.to_string(ivm.segmentHistory)) + fail = true + end + + -- Check segments. + for k, seg in pairs(segments) do + if (seg.endTimeMs or 1/0) <= seg.startTimeMs then + msg.error("Segment " .. k .. " ends before it starts") + fail = true + end + local has_scene = false + for i, mom in ipairs(moments[k] or {}) do + if string.sub(mom.type, 1, 6) == "scene:" and + not (mom.trackingInfo and + mom.trackingInfo.optionType == "fakeOption") then + has_scene = true + break + end + end + if count(seg.next) > 1 and not has_scene and not segment_groups[k] then + msg.error("Segment " .. k .. " requires a branching moment " .. + "or a segment group") + fail = true + end + end + + -- Check moments. + local n_moments = 0 + for k, ml in pairs(moments) do + n_moments = n_moments + #ml + for i, mi in ipairs(ml) do + local ki = k .. "/" .. i + + if mi.endMs <= mi.startMs then + msg.error("Moment " .. ki .. " ends before it starts") + fail = true + end + if mi.startMs < segments[k].startTimeMs then + msg.error("Moment " .. ki .. " starts before its segment does") + fail = true + end + if mi.endMs > (segments[k].endTimeMs or 1/0) then + msg.error("Moment " .. ki .. " ends after its segment does") + fail = true + end + + -- Scene moments. + if string.sub(mi.type, 1, 6) == "scene:" then + if not mi.choices then + msg.error("Moment " .. ki .. " has no branching choices") + fail = true + end + if not (mi.uiDisplayMS and mi.uiHideMS) then + msg.error("Moment " .. ki .. " has no display interval") + fail = true + else + if mi.uiHideMS <= mi.uiDisplayMS then + msg.error("Moment " .. ki .. "'s display interval is empty") + fail = true + end + if mi.uiDisplayMS < mi.startMs or mi.uiHideMS >= mi.endMs then + msg.warn ("Moment " .. ki .. "'s display interval overflows " .. + "out of bounds") + end + end + if mi.endMs < (segments[k].endTimeMs or 1/0) and + not (mi.trackingInfo and + mi.trackingInfo.optionType == "fakeOption") then + msg.warn ("Moment " .. ki .. " ends before its segment does") + end + + for j, mj in ipairs(ml) do + local kj = k .. "/" .. j + if i ~= j and mi.startMs <= mj.startMs and mj.startMs < mi.endMs then + msg.error("Moment " .. kj .. " starts while " .. ki .. + " is active") + fail = true + end + end + + -- Notification moments. + elseif mi.type == "notification:playbackImpression" then + if mi.choices then + msg.error("Moment " .. ki .. " has branching choices") + fail = true + end + if not mi.impressionData then + msg.warn ("Moment " .. ki .. " has no impression data") + end + + elseif mi.type == "notification:action" then + if mi.choices then + msg.error("Moment " .. ki .. " has branching choices") + fail = true + end + + else + msg.error ("Moment " .. ki .. " has invalid type: " .. mi.type) + fail = true + end + end + end + + if fail then + deactivate() + return + end + + -- Display stats. + + msg.verbose("Loaded JSON data files:\n" .. + " " .. count(segments) .. " segments\n" .. + " " .. n_moments .. " interactive moments\n" .. + " " .. count(preconditions) .. " preconditions\n" .. + " " .. count(segment_groups) .. " segment groups\n" .. + " " .. count(state.vars) .. " state variables") + + state.active = true + state.hist_idx = 0 + state.hist = {} + update_controls() +end + + +--[[ Jump to initial segment at beginning of playback ]]----------------------- + +function on_file_loaded(_) + if not state.active then return end + mp.register_event("tick", on_tick) + load_segment(initial_segment) + process_events(segments[initial_segment].startTimeMs, { ffwd = true }) +end + + +--[[ Process queued events on each frame ]]------------------------------------ + +function on_tick(_) + process_events() +end + + +--[[ Register script entry-point events ]]------------------------------------- + +mp.register_event("start-file", on_start_file) +mp.register_event("file-loaded", on_file_loaded) |