live streams as well as pre-recorded streams

[mrfragger]

screenshot is from live stream (not pre-recorded)

p-f script-binding load-chat #! Video Online > YT Live Chat > Download / Load YT Pre-Recorded Live Chat
p-0 script-binding live-chat #! Video Online > YT Live Chat > For Live Stream
p-g script-binding unload-chat #! Video Online > YT Live Chat > Unload Chat
p-h script-binding chat-hidden #! Video Online > YT Live Chat > Hide / Show Chat
p-i script-binding chat-anchor #! Video Online > YT Live Chat > Change Position

when do you live streams p-0 wait 30 to 45 seconds for anything to display. Then once it starts going there will be flood..another 30 seconds should be normal and all messages are delayed about 15 seconds but it does work with live streams. Basically works by reading tail end of part file and de-duplication of messages.

p-f works just like before downloads entire json chat file then loads it up.

[mrfragger]

TwitterColorEmoji.ttf.zip

Twitter Color Emoji font 6MB cuz svgs stripped out. Displays many colored-emojis in black and white. The original one is 14MB and most people don't know how to stripped out svgs.

[mrfragger]

local utils = require 'mp.utils'
local options = require 'mp.options'

local messages = nil
local chat_overlay = nil
local chat_hidden = false

local recent_messages = {}
local message_buffer_duration = 30000
local display_delay_live = 1000
local display_delay_recorded = 0
local message_tracking_duration = 300000

local processed_messages = {}
local processed_message_timestamps = {}
local message_content_hash = {}
local last_part_file_size = 0
local processed_lines = 0
local current_chat_file = nil
local display_timer = nil
local message_display_timer = nil
local cleanup_timer = nil
local file_check_timer = nil
local last_activity_time = nil
local last_log_time = 0
local is_live_stream = false
local download_process = nil
local part_monitor_timer = nil
local is_windows = package.config:sub(1,1) ~= "/"
local xdg_data_home = os.getenv("HOME") .. "/.config/mpv"

local opts = {}
opts['auto-load'] = true
opts['live-chat-directory'] = is_windows and 'C:/' or (xdg_data_home .. '/youtube-live-chats')
opts['yt-dlp-path'] = 'yt-dlp'
opts['show-author'] = true
opts['author-color'] = 'random'
opts['author-border-color'] = '000000'
opts['message-color'] = 'ffffff'
opts['message-border-color'] = '000000'
opts['font'] = 'Twitter Color Emoji'
opts['font-size'] = 24
opts['border-size'] = 4
opts['message-duration'] = 15000
opts['max-message-line-length'] = 100
opts['message-gap'] = 1
opts['anchor'] = 7
opts['update-interval'] = 1
opts['messages-per-second'] = 3
opts['debug-duplicates'] = true

options.read_options(opts)
options.read_options(opts, "mpv-youtube-chat")

local NORMAL = 0
local SUPERCHAT = 1

local active_messages = {}
local message_queue = {}

function wrap_text(text, max_length)
 if not text or text:len() <= max_length then
     return text
 end

 local lines = {}
 local current_line = ""

 for word in text:gmatch("%S+") do
     if current_line:len() + word:len() + 1 > max_length then
         if current_line ~= "" then
             table.insert(lines, current_line)
             current_line = word
         else
             table.insert(lines, word:sub(1, max_length))
             current_line = word:sub(max_length + 1)
         end
     else
         if current_line == "" then
             current_line = word
         else
             current_line = current_line .. " " .. word
         end
     end
 end

 if current_line ~= "" then
     table.insert(lines, current_line)
 end

 return table.concat(lines, "\\N")
end

function update_chat_display()
   local current_video_time = mp.get_property_native("time-pos")
   if not current_video_time then
       return
   end

   if chat_hidden then
       return
   end

   local current_video_ms = current_video_time * 1000
   local visible_messages = {}

   for _, message in ipairs(active_messages) do
       local should_show = false

       if is_live_stream then
           local message_age_ms = current_video_ms - message.display_time
           should_show = (message_age_ms >= 0 and message_age_ms <= opts['message-duration'])
       else
           local display_time = message.time + display_delay_recorded
           local message_end_time = display_time + opts['message-duration']
           should_show = (current_video_ms >= display_time and current_video_ms <= message_end_time)
       end

       if should_show then
           table.insert(visible_messages, message)
       end
   end

   table.sort(visible_messages, function(a, b)
       if is_live_stream then
           return (a.display_time or 0) > (b.display_time or 0)
       else
           return a.time > b.time
       end
   end)

   if not chat_overlay then
       return
   end

   chat_overlay.data = ''

   if #visible_messages > 0 then
       for i, message in ipairs(visible_messages) do
           if i > 20 then break end

           local message_string = format_message(message)

           if opts['anchor'] <= 3 then
               chat_overlay.data = chat_overlay.data .. '\n' .. message_string
           else
               chat_overlay.data = message_string .. '\n' .. chat_overlay.data
           end
       end
   end

   pcall(function()
       chat_overlay:update()
   end)
end

function display_next_message()
 if #message_queue > 0 then
     local message = table.remove(message_queue, 1)
     local current_video_time = mp.get_property_native("time-pos")
     if current_video_time then
         message.display_time = current_video_time * 1000
         table.insert(active_messages, message)
     end
 end
end

function add_message_to_buffer(message)
   local current_video_time = mp.get_property_native("time-pos")
   if not current_video_time then
       return
   end

   local current_video_ms = current_video_time * 1000

   if is_live_stream then
       message.shifted_time = current_video_ms + display_delay_live
   else
       message.shifted_time = message.time + display_delay_recorded
   end

   message.original_time = message.time
   table.insert(recent_messages, message)

   local cutoff_time = current_video_ms - message_buffer_duration
   local new_buffer = {}

   for _, msg in ipairs(recent_messages) do
       if msg.shifted_time > cutoff_time then
           table.insert(new_buffer, msg)
       end
   end

   recent_messages = new_buffer
end

function process_messages_for_display()
   local current_video_time = mp.get_property_native("time-pos")
   if not current_video_time then
       return
   end

   local current_video_ms = current_video_time * 1000

   local messages_to_remove = {}

   for i, message in ipairs(recent_messages) do
       local should_display = false

       if is_live_stream then
           should_display = current_video_ms >= message.shifted_time
       else
           should_display = current_video_ms >= message.shifted_time
       end

       local not_already_queued = true

       for _, queued in ipairs(message_queue) do
           if queued.id == message.id then
               not_already_queued = false
               break
           end
       end

       for _, active in ipairs(active_messages) do
           if active.id == message.id then
               not_already_queued = false
               break
           end
       end

       if should_display and not_already_queued then
           table.insert(message_queue, message)
           table.insert(messages_to_remove, i)
       end
   end

   for i = #messages_to_remove, 1, -1 do
       local index = messages_to_remove[i]
       table.remove(recent_messages, index)
   end

   local new_active = {}
   for _, msg in ipairs(active_messages) do
       local message_expired = false

       if is_live_stream then
           local message_age = current_video_ms - (msg.display_time or 0)
           message_expired = message_age > opts['message-duration']
       else
           local message_end_time = msg.time + display_delay_recorded + opts['message-duration']
           message_expired = current_video_ms > message_end_time
       end

       if not message_expired then
           table.insert(new_active, msg)
       end
   end
   active_messages = new_active
end

function cleanup_old_message_tracking()
 local current_time = os.time() * 1000
 local cutoff_time = current_time - message_tracking_duration

 local new_processed_messages = {}
 local new_processed_timestamps = {}
 local new_content_hash = {}

 for msg_id, _ in pairs(processed_messages) do
     local timestamp = processed_message_timestamps[msg_id]
     if timestamp and timestamp > cutoff_time then
         new_processed_messages[msg_id] = true
         new_processed_timestamps[msg_id] = timestamp
         if message_content_hash[msg_id] then
             new_content_hash[msg_id] = message_content_hash[msg_id]
         end
     end
 end

 processed_messages = new_processed_messages
 processed_message_timestamps = new_processed_timestamps
 message_content_hash = new_content_hash
end


function monitor_part_file()
    if not is_live_stream then
        stop_monitoring_timers()
        return
    end

    if not current_chat_file then
        return
    end

    local video_id = current_chat_file:match("([^/]+)%.live_chat%.json$")
    if not video_id then
        return
    end

    local part_filename = string.format("%s/%s.live_chat.json.part", opts['live-chat-directory'], video_id)

    if not file_exists(part_filename) then
        if not last_activity_time then
            last_activity_time = os.time()
        end
        return
    end

    local current_size = get_file_size(part_filename)

    if current_size > last_part_file_size then
        parse_part_file_incremental(part_filename, last_part_file_size)
        last_part_file_size = current_size
        last_activity_time = os.time()
    else
        if not last_activity_time then
            last_activity_time = os.time()
        end

        local inactive_duration = os.time() - last_activity_time
        if inactive_duration > 300 then
            mp.msg.info("No new chat messages for 5 minutes, stopping chat monitoring")
            stop_monitoring_timers()
            return
        end
    end
end

function restart_ytdlp_if_needed()
 if not current_chat_file then
     return
 end

 local path = mp.get_property_native('path')
 if not path or not (path:find('^http://') or path:find('^https://')) then
     return
 end

 local track_list = mp.get_property_native("track-list")
 local external_filename = nil

 if track_list then
     for i,v in pairs(track_list) do
         if v.type == 'sub' and v.lang == 'live_chat' then
             external_filename = v['external-filename']
             external_filename = external_filename:gsub("^.*https", "https")
             external_filename = external_filename:gsub("%%75%%", "")
             break
         end
     end
 end

 if external_filename then
     start_ytdlp_download(external_filename)
     last_activity_time = os.time()
 end
end

function parse_part_file_incremental(part_filename, last_size)
 local file = io.open(part_filename, "r")
 if not file then
     return
 end

 if is_live_stream then
     file:seek("set", last_size)
 else
     file:seek("set", 0)
     for i = 1, processed_lines do
         file:read("*line")
     end
 end

 local new_messages = 0
 local line_count = 0
 local duplicate_count = 0
 local ignored_count = 0

 for line in file:lines() do
     line_count = line_count + 1
     if line:match("%S") then
         local success, entry = pcall(utils.parse_json, line)
         if success and entry and entry.replayChatItemAction then
             local result = process_chat_entry(entry)
             if result == "new" then
                 new_messages = new_messages + 1
             elseif result == "duplicate" then
                 duplicate_count = duplicate_count + 1
             else
                 ignored_count = ignored_count + 1
             end
         end
     end
 end

 if not is_live_stream then
     processed_lines = processed_lines + line_count
 end

 file:close()
end

function process_chat_entry(entry)
   local time = tonumber(entry.videoOffsetTimeMsec or entry.replayChatItemAction.videoOffsetTimeMsec)

   if time and entry.replayChatItemAction.actions then
       for _,action in ipairs(entry.replayChatItemAction.actions) do
           if action.addChatItemAction then
               if action.addChatItemAction.item.liveChatTextMessageRenderer then
                   local renderer = action.addChatItemAction.item.liveChatTextMessageRenderer

                   local author = (renderer.authorName and renderer.authorName.simpleText) or 'Unknown'
                   local message = ""

                   if renderer.message and renderer.message.runs then
                       for _,data in ipairs(renderer.message.runs) do
                           if data.text then
                               message = message .. data.text
                           elseif data.emoji then
                               message = message .. (data.emoji.emojiId or "[emoji]")
                           end
                       end
                   end

                   if is_live_stream then
                       local msg_id = generate_message_id(time, author, message, NORMAL)
                       local content_key = author .. "|" .. message
                       local time_author_key = time .. "|" .. author

                       if processed_messages[msg_id] then
                           return "duplicate"
                       end

                       if message_content_hash[content_key] then
                           return "duplicate"
                       end

                       if message_content_hash[time_author_key] then
                           return "duplicate"
                       end

                       local current_time = os.time() * 1000
                       processed_messages[msg_id] = true
                       processed_message_timestamps[msg_id] = current_time
                       message_content_hash[content_key] = current_time
                       message_content_hash[time_author_key] = current_time
                   end

                   local chat_message = {
                       type = NORMAL,
                       author = author,
                       author_color = string_to_color(renderer.authorExternalChannelId or ""),
                       contents = message,
                       time = time,
                       id = is_live_stream and generate_message_id(time, author, message, NORMAL) or tostring(time) .. "_" .. author
                   }

                   if is_live_stream then
                       add_message_to_buffer(chat_message)
                   else
                       table.insert(active_messages, chat_message)
                   end

                   return "new"
               end
           end
       end
   end
   return "ignored"
end

function file_exists(name)
 local f = io.open(name, "r")
 if f ~= nil then
     f:close()
     return true
 else
     return false
 end
end

function get_file_size(filename)
 local file = io.open(filename, "r")
 if not file then return 0 end
 local size = file:seek("end")
 file:close()
 return size
end

function generate_message_id(time, author, contents, msg_type)
 local content_preview = contents and contents:sub(1, 50) or ""
 return string.format("%s|%s|%s|%d", tostring(time), author or "", content_preview, msg_type)
end

function string_to_color(str)
 local hash = 5381
 for i = 1,str:len() do
     hash = (33 * hash + str:byte(i)) % 16777216
 end
 return hash
end

function swap_color_string(str)
 local r = str:sub(1, 2)
 local g = str:sub(3, 4)
 local b = str:sub(5, 6)
 return b .. g .. r
end

function format_message(message)
 local message_string = chat_message_to_string(message)
 local formatting = '{\\an' .. opts['anchor'] .. '}'
                 .. '{\\fs' .. opts['font-size'] .. '}'
                 .. '{\\fn' .. opts['font'] .. '}'
                 .. '{\\bord' .. opts['border-size'] .. '}'
                 .. string.format('{\\1c&H%s&}', swap_color_string(opts['message-color']))
                 .. string.format('{\\3c&H%s&}', swap_color_string(opts['message-border-color']))

 return formatting .. message_string
end

function chat_message_to_string(message)
 if message.type == NORMAL then
     local wrapped_contents = wrap_text(message.contents, opts['max-message-line-length'])
     if opts['show-author'] then
         return string.format(
             '{\\1c&H%06x&}{\\3c&H%s&}%s{\\1c&H%s&}{\\3c&H%s&}: %s',
             message.author_color,
             swap_color_string(opts['author-border-color']),
             message.author,
             swap_color_string(opts['message-color']),
             swap_color_string(opts['message-border-color']),
             wrapped_contents
         )
     else
         return wrapped_contents
     end
 end
 return ""
end

function start_ytdlp_download(external_filename)
   local cmd_args = {
       opts['yt-dlp-path'],
       '--skip-download',
       '--write-subs',
       '--sub-langs', 'live_chat',
       external_filename,
       '-o', '%(id)s.%(ext)s',
       '-P', opts['live-chat-directory']
   }

   download_process = mp.command_native_async({
       name = "subprocess",
       playback_only = false,
       args = cmd_args
   }, function(success, result, error)
       download_process = nil

       if success then
           mp.add_timeout(2, function()
               load_complete_chat_file()
           end)
       end
   end)
end

function load_complete_chat_file()
 if not current_chat_file then
     return
 end

 if file_exists(current_chat_file) then
     is_live_stream = false
     processed_lines = 0
     parse_part_file_incremental(current_chat_file, 0)
 end
end

function start_display_timers()
 if display_timer then
     display_timer:kill()
 end
 display_timer = mp.add_periodic_timer(opts['update-interval'], function()
     process_messages_for_display()
     update_chat_display()
 end)

 if message_display_timer then
     message_display_timer:kill()
 end
 local display_interval = 1.0 / opts['messages-per-second']
 message_display_timer = mp.add_periodic_timer(display_interval, display_next_message)

 if cleanup_timer then
     cleanup_timer:kill()
 end
 cleanup_timer = mp.add_periodic_timer(60, cleanup_old_message_tracking)
end

function start_monitoring_timers()
    if part_monitor_timer then
        part_monitor_timer:kill()
    end
    part_monitor_timer = mp.add_periodic_timer(1, monitor_part_file)
end

function stop_monitoring_timers()
    if part_monitor_timer then
        part_monitor_timer:kill()
        part_monitor_timer = nil
    end
end

function load_live_chat(filename, interactive)
   local path = mp.get_property_native('path')
   local external_filename = nil

   if filename == nil then
       local is_network = path and (path:find('^http://') ~= nil or path:find('^https://') ~= nil)

       if is_network then
           local track_list = mp.get_property_native("track-list")

           if track_list then
               for i,v in pairs(track_list) do
                   if v.type == 'sub' and v.lang == 'live_chat' then
                       external_filename = v['external-filename']
                       external_filename = external_filename:gsub("^.*https", "https")
                       external_filename = external_filename:gsub("%%75%%", "")

                       local id = external_filename:gsub("^.*[?&]v=", ""):gsub("&.*", "")
                       filename = string.format("%s/%s.live_chat.json", opts['live-chat-directory'], id)
                       break
                   end
               end
           end
       end
   end

   if filename then
       current_chat_file = filename
       last_part_file_size = 0
       processed_lines = 0
       is_live_stream = false
       last_activity_time = nil

       if not chat_overlay then
           chat_overlay = mp.create_osd_overlay("ass-events")
           chat_overlay.z = 1000
       end

       if file_exists(filename) then
           is_live_stream = false
           parse_part_file_incremental(filename, 0)
           start_display_timers()
           return
       end

       if external_filename then
           start_ytdlp_download(external_filename)
           start_display_timers()
       end
   end
end

function enable_live_monitoring()
    if not current_chat_file then
        return
    end

    local video_id = current_chat_file:match("([^/]+)%.live_chat%.json$")
    if not video_id then
        return
    end

    is_live_stream = true
    active_messages = {}
    message_queue = {}
    recent_messages = {}
    last_part_file_size = 0
    last_activity_time = os.time()

    local path = mp.get_property_native('path')
    if path and (path:find('^http://') or path:find('^https://')) then
        local track_list = mp.get_property_native("track-list")
        local external_filename = nil
        if track_list then
            for i,v in pairs(track_list) do
                if v.type == 'sub' and v.lang == 'live_chat' then
                    external_filename = v['external-filename']
                    external_filename = external_filename:gsub("^.*https", "https")
                    external_filename = external_filename:gsub("%%75%%", "")
                    break
                end
            end
        end

        if external_filename then
            local live_cmd_args = {
                opts['yt-dlp-path'],
                '--skip-download',
                '--write-subs',
                '--sub-langs', 'live_chat',
                '--live-from-start',
                external_filename,
                '-o', '%(id)s.%(ext)s',
                '-P', opts['live-chat-directory']
            }

            mp.command_native_async({
                name = "subprocess",
                playback_only = false,
                args = live_cmd_args
            }, function(success, result, error)
            end)

            mp.add_timeout(3, function()
                start_monitoring_timers()
            end)
        end
    end
end

function reset_function()
    if part_monitor_timer then
        part_monitor_timer:kill()
        part_monitor_timer = nil
    end
    if display_timer then
        display_timer:kill()
        display_timer = nil
    end
    if message_display_timer then
        message_display_timer:kill()
        message_display_timer = nil
    end
    if cleanup_timer then
        cleanup_timer:kill()
        cleanup_timer = nil
    end
    if download_process then
        download_process = nil
    end
    if chat_overlay then
        chat_overlay:remove()
        chat_overlay = nil
    end

    recent_messages = {}
    processed_messages = {}
    processed_message_timestamps = {}
    message_content_hash = {}
    active_messages = {}
    message_queue = {}
    last_part_file_size = 0
    processed_lines = 0
    current_chat_file = nil
    chat_hidden = false
    last_log_time = 0
    is_live_stream = false
    last_activity_time = nil
end

mp.register_script_message("load-chat", function()
   load_live_chat(nil, true)
end)

mp.register_script_message("enable-live-chat", function()
   enable_live_monitoring()
end)

mp.register_event("end-file", reset_function)

mp.add_key_binding(nil, "load-chat", function()
   load_live_chat(nil, true)
end)

mp.add_key_binding(nil, "unload-chat", function()
   reset_function()
end)

mp.add_key_binding(nil, "chat-hidden", function()
   chat_hidden = not chat_hidden
   if chat_hidden then
       if chat_overlay then
           chat_overlay.data = ''
           chat_overlay:update()
       end
   else
       update_chat_display()
   end
end)

mp.add_key_binding(nil, "live-chat", function()
   reset_function()
   load_live_chat(nil, true)
   mp.add_timeout(0.5, function()
       enable_live_monitoring()
   end)
end)