OSD stuff and Android fixes

Signed-off-by: Andrew Opalach <andrew@akon.city>

38 files changed, 1359 insertions, 240 deletions

diff --git a/src/buffer/clock.c b/src/buffer/clock.c
index fbe7ec5..19f721c 100644
--- a/src/buffer/clock.c
+++ b/src/buffer/clock.c
@@ -86,7 +86,8 @@ bool camu_clock_pause(struct camu_clock *clock, u64 target)
 
     f64 tick = atomic_load(f64)(&clock->tick, AL_ATOMIC_RELAXED);
 
-    f64 current = nn_get_tick(), pause = current;
+    f64 current = nn_get_tick();
+    f64 pause = current;
     if (target > 0) {
         pause = calc_tick_offset(pause, nn_get_timestamp(), target);
     }
@@ -144,6 +145,14 @@ void camu_clock_resume(struct camu_clock *clock, u64 target)
     atomic_store(f64)(&clock->pause, RUNNING, AL_ATOMIC_RELEASE);
 }
 
+// @TODO: This only works for local sink.
+bool camu_clock_is_user_paused(struct camu_clock *clock)
+{
+    f64 tick = atomic_load(f64)(&clock->tick, AL_ATOMIC_RELAXED);
+    f64 pause = atomic_load(f64)(&clock->pause, AL_ATOMIC_RELAXED);
+    return tick != SET && pause <= 0.0;
+}
+
 f64 camu_clock_get_base_pts(struct camu_clock *clock)
 {
     return clock->base;
diff --git a/src/buffer/clock.h b/src/buffer/clock.h
index eb3dcaf..e1a2d9e 100644
--- a/src/buffer/clock.h
+++ b/src/buffer/clock.h
@@ -53,6 +53,7 @@ bool camu_clock_pause(struct camu_clock *clock, u64 target);
 void camu_clock_external_pause(struct camu_clock *clock);
 void camu_clock_resume(struct camu_clock *clock, u64 target);
 
+bool camu_clock_is_user_paused(struct camu_clock *clock);
 f64 camu_clock_get_base_pts(struct camu_clock *clock);
 f64 camu_clock_get_pts(struct camu_clock *clock, f64 latency, bool allow_set, bool *armed_for_pause);
 f64 camu_clock_get_last_pts(struct camu_clock *clock);
diff --git a/src/cache/backings/file.c b/src/cache/backings/file.c
index 06cc600..c98c8d5 100644
--- a/src/cache/backings/file.c
+++ b/src/cache/backings/file.c
@@ -63,7 +63,7 @@ static void file_backing_set_size(struct cch_backing *backing, off_t size, bool
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
     nn_mutex_lock(&file->mutex);
     file->backing.size = size;
-    if (expand_to_size && (size_t)size > file->file.size) {
+    if (expand_to_size || (size > 0 && size < file->file.size)) {
         nn_file_truncate(&file->file, size);
     }
     nn_mutex_unlock(&file->mutex);
diff --git a/src/cache/backings/file_common.h b/src/cache/backings/file_common.h
index 6650dd1..6dd4e96 100644
--- a/src/cache/backings/file_common.h
+++ b/src/cache/backings/file_common.h
@@ -27,7 +27,19 @@ static void file_backing_finalize(struct cch_backing *backing)
 static bool file_open_internal(struct cch_backing_file *file, str *path, size_t size)
 {
     s32 flags = (size != 0) ? NNWT_FILE_CREATE : NNWT_FILE_READONLY;
-    if (!nn_file_open(&file->file, path, flags)) return false;
+    if (al_str_cmp(path, &al_str_c("fd://"), 0, 5) == 0) {
+        str fd_str = al_str_substr(path, 5, path->length);
+        bool error;
+        s32 fd = (s32)al_str_to_long(&fd_str, 10, &error);
+        if (error) return false;
+        if (!nn_file_wrap_fd(&file->file, fd)) {
+            return false;
+        }
+    } else {
+        if (!nn_file_open(&file->file, path, flags)) {
+            return false;
+        }
+    }
     size_t filesize = file->file.size;
     if (!size) {
         file->backing.size = filesize;
diff --git a/src/cache/backings/file_mapped.c b/src/cache/backings/file_mapped.c
index 7657a21..24ac005 100644
--- a/src/cache/backings/file_mapped.c
+++ b/src/cache/backings/file_mapped.c
@@ -46,14 +46,12 @@ static void file_backing_unlock(struct cch_backing *backing)
 static void file_backing_set_size(struct cch_backing *backing, off_t size, bool expand_to_size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    al_assert(expand_to_size || size == 0);
     nn_mutex_lock(&file->mutex);
     file->backing.size = size;
-    if ((size_t)size > file->file.size) {
+    if (expand_to_size || (size > 0 && size < file->file.size)) {
         nn_file_munmap(&file->file, file->u.map);
         nn_file_truncate(&file->file, size);
         file->u.map = nn_file_mmap(&file->file);
-        file->file.size = size;
     }
     nn_mutex_unlock(&file->mutex);
 }
diff --git a/src/cache/handle.c b/src/cache/handle.c
index 74db306..ebc3842 100644
--- a/src/cache/handle.c
+++ b/src/cache/handle.c
@@ -37,6 +37,7 @@ s32 cch_handle_read(struct cch_handle *handle, u8 *buf, s32 count)
     al_assert(count >= 0);
     handle->wait.start = handle->pointer;
     handle->wait.end = handle->pointer + count;
+    log_trace("wait_for_range(%zd, %zd)", handle->wait.start, handle->wait.end);
     if (!handler->wait_for_range(handler, &handle->wait)) {
         log_trace("Wait for range (%zd-%zd) failed.", handle->wait.start, handle->wait.end);
         return CAMU_ERR_EOF;
@@ -52,7 +53,7 @@ s32 cch_handle_read(struct cch_handle *handle, u8 *buf, s32 count)
         backing->read(backing, buf, handle->pointer, &available);
     }
     handle->pointer += available;
-    log_trace("read(%u), pointer: %zd.", count, handle->pointer);
+    log_trace("read(%u), avail: %zu, pointer: %zd.", count, available, handle->pointer);
     return (available > 0) ? (s32)available : CAMU_ERR_EOF;
 }
 
diff --git a/src/cache/handlers/cdio.c b/src/cache/handlers/cdio.c
index 8326868..90c5ce9 100644
--- a/src/cache/handlers/cdio.c
+++ b/src/cache/handlers/cdio.c
@@ -1,6 +1,7 @@
 #define AL_LOG_SECTION "cache_cdio"
 //#define AL_LOG_ENABLE_TRACE
 #include <al/log.h>
+#include <nnwt/common.h>
 
 #include "../../codec/codec.h"
 
@@ -51,9 +52,10 @@ static nn_thread_result NNWT_THREADCALL cd_read_thread(void *userdata)
         cdio_log_messages(cdio);
         al_assert(ret <= SECTORS_PER_STEP);
         off_t pointer = cdio->sector * CDIO_CD_FRAMESIZE_RAW;
-        size_t size;
+        size_t size = BYTES_PER_STEP;
         u8 *ptr = cdio->backing->get_ptr(cdio->backing, pointer, &size);
         al_assert(size >= BYTES_PER_STEP);
+        log_trace("cdio_read(), ret: %ld, size: %zu", ret, size);
         if (ret == SECTORS_PER_STEP) {
             al_memcpy(ptr, nn_buffer_get_ptr(&cdio->buffer, 0), BYTES_PER_STEP);
         } else if (ret == -10) {
@@ -192,7 +194,10 @@ static bool open_cd_drive(struct cch_handler_cdio *cdio)
 
 struct cch_entry *cch_handler_cdio_create(void)
 {
-    struct cch_backing *backing = cch_backing_file_create(&al_str_c("/tmp/camu_cd_data"), 4096);
+    str tmpfile;
+    al_str_clone(&tmpfile, &nn_temp_directory);
+    nn_path_append(&tmpfile, &al_str_c("camu_cd_data"));
+    struct cch_backing *backing = cch_backing_file_create(&tmpfile, 4096);
     if (!backing) return NULL;
     struct cch_handler_cdio *cdio = al_alloc_object(struct cch_handler_cdio);
     cdio->backing = backing;
diff --git a/src/cache/handlers/http.c b/src/cache/handlers/http.c
index f57d3eb..4fe82e2 100644
--- a/src/cache/handlers/http.c
+++ b/src/cache/handlers/http.c
@@ -1,10 +1,12 @@
 #define AL_LOG_SECTION "cache_http"
+#define AL_LOG_ENABLE_TRACE
 #include <al/log.h>
+#include <nnwt/common.h>
 
 #include "../../codec/codec.h"
 
 #include "../backings/memory.h"
-//#include "../backings/file.h"
+#include "../backings/file.h"
 #include "../threaded_waits.h"
 #include "../wait.h"
 
@@ -78,11 +80,14 @@ static void handler_http_maybe_spawn_worker(struct cch_handler *handler, size_t
 {
     struct cch_handler_http *http = (struct cch_handler_http *)handler;
     (void)index;
-    al_array_push(http->requests, (struct nn_http){ 0 });
-    struct nn_http *request = &al_array_last(http->requests);
+    struct nn_http *request = al_alloc_object(struct nn_http);
+    al_array_push(http->requests, request);
     nn_http_init(request);
     nn_http_set_url(request, &http->url);
     nn_http_set_user_agent(request, &USER_AGENT);
+    if (index != 0) {
+        nn_http_set_range(request, index, 0);
+    }
     nn_http_request_stream(request, NNWT_HTTP_GET, http->loop, http_callback, http);
     log_debug("Spawning worker for %.*s.", al_str_x(&http->url));
 }
@@ -104,7 +109,7 @@ static void handler_http_free(struct cch_handler **handler)
     struct cch_handler_http *http = (struct cch_handler_http *)*handler;
     cch_threaded_waits_disable_all(&http->waits);
     struct nn_http *request;
-    al_array_foreach_ptr(http->requests, i, request) {
+    al_array_foreach(http->requests, i, request) {
         nn_http_close(request);
     }
     cch_threaded_waits_close(&http->waits);
@@ -115,6 +120,7 @@ static void handler_http_free(struct cch_handler **handler)
     *handler = NULL;
 }
 
+
 struct cch_entry *cch_handler_http_create(str *url, struct nn_event_loop *loop)
 {
     struct cch_backing *backing = cch_backing_memory_create(1024 * 128);
diff --git a/src/cache/handlers/http.h b/src/cache/handlers/http.h
index 93efdae..3e0bfca 100644
--- a/src/cache/handlers/http.h
+++ b/src/cache/handlers/http.h
@@ -14,7 +14,7 @@ struct cch_handler_http {
     struct nn_event_loop *loop;
     str url;
     off_t pointer;
-    array(struct nn_http) requests;
+    array(struct nn_http *) requests;
     struct cch_threaded_waits waits;
 };
 
diff --git a/src/codec/ffmpeg/common.c b/src/codec/ffmpeg/common.c
index 5e10bcb..bda7a18 100644
--- a/src/codec/ffmpeg/common.c
+++ b/src/codec/ffmpeg/common.c
@@ -17,7 +17,7 @@ s64 camu_ff_get_frame_duration(AVFrame *frame)
 }
 
 // https://code.videolan.org/videolan/libplacebo/-/blob/a7a18af88ff0a17c04840dcb3246047bb6b46df3/src/include/libplacebo/utils/libav_internal.h#L854
-const u8 *camu_ff_get_stream_side_data(const AVStream *stream, enum AVPacketSideDataType type)
+const u8 *camu_ff_get_stream_side_data(AVStream *stream, enum AVPacketSideDataType type)
 {
 #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(60, 15, 100)
     AVCodecParameters *codecpar = stream->codecpar;
diff --git a/src/codec/ffmpeg/common.h b/src/codec/ffmpeg/common.h
index b49ce88..5a0be3d 100644
--- a/src/codec/ffmpeg/common.h
+++ b/src/codec/ffmpeg/common.h
@@ -10,7 +10,7 @@
 
 s64 camu_ff_get_frame_duration(AVFrame *frame);
 
-const u8 *camu_ff_get_stream_side_data(const AVStream *stream, enum AVPacketSideDataType type);
+const u8 *camu_ff_get_stream_side_data(AVStream *stream, enum AVPacketSideDataType type);
 const u8 *camu_ff_get_frame_side_data(AVFrame *frame, enum AVFrameSideDataType type);
 
 // userdata, level, fmt, args
diff --git a/src/codec/ffmpeg/encoder.c b/src/codec/ffmpeg/encoder.c
index 641acc5..7824461 100644
--- a/src/codec/ffmpeg/encoder.c
+++ b/src/codec/ffmpeg/encoder.c
@@ -44,10 +44,9 @@ bool camu_ff_encoder_init(struct camu_ff_encoder *enc, char *encoder_name, char
         enc->codec_context->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
     }
 
+    u32 kbps = bitrate / 1000;
     AVDictionary *opts = NULL;
-    char kbps[16];
-    al_snprintf(kbps, sizeof(kbps), "%uk", bitrate / 1000);
-    av_dict_set(&opts, "b", kbps, 0);
+    av_dict_set(&opts, "b", al_print_s32(kbps)->data, 0);
     av_dict_set(&opts, "vbr", "off", 0);
     av_dict_set(&opts, "compression_level", "10", 0);
     av_dict_set(&opts, "frame_duration", "20", 0);
@@ -59,7 +58,7 @@ bool camu_ff_encoder_init(struct camu_ff_encoder *enc, char *encoder_name, char
     }
     av_dict_free(&opts);
 
-    log_info("Encoder: %s (%s) %sbps.", codec->name,
+    log_info("Encoder: %s (%s) %ubps.", codec->name,
         codec->long_name ? codec->long_name : codec->name, kbps);
 
     AVCodecContext *out_codec = enc->codec_context;
diff --git a/src/fruits/cmv/cmv.c b/src/fruits/cmv/cmv.c
index 58c8e32..74e3555 100644
--- a/src/fruits/cmv/cmv.c
+++ b/src/fruits/cmv/cmv.c
@@ -53,6 +53,10 @@ static nn_thread_result NNWT_THREADCALL event_loop_thread(void *userdata)
 
 static bool decode_addr(str *addr, str *enc)
 {
+    if (al_str_find(enc, '.') != AL_STR_NO_POS) {
+        al_str_clone(addr, enc);
+        return true;
+    }
     char value[4]; // max = 255.
     for (u32 i = 0; i < 8; i += 2) {
         str sub = al_str_substr(enc, i, i + 2);
@@ -75,40 +79,39 @@ static bool parse_exe_name(str *exe_name, str *addr)
     u32 index = al_str_rfind(exe_name, '/');
     if (index == AL_STR_NO_POS) {
         if ((index = al_str_rfind(exe_name, '\\')) == AL_STR_NO_POS) {
-            goto def;
+            return false;
         }
     }
 
     str sub = al_str_substr(exe_name, index + 1, exe_name->length);
     if (al_str_cmp(&sub, &al_str_c("sink-"), 0, 5) != 0) {
-        goto def;
+        return false;
     }
     sub = al_str_substr(&sub, 5, sub.length);
 
     // Skip version.
     if ((index = al_str_find(&sub, '-')) == AL_STR_NO_POS) {
-        goto def;
+        return false;
     }
     sub = al_str_substr(&sub, index + 1, sub.length);
 
     if ((index = al_str_find(&sub, '.')) != AL_STR_NO_POS) {
         sub = al_str_substr(&sub, 0, index);
     }
-    al_str_from(addr, "");
     decode_addr(addr, &sub);
     log_debug("Parsed address %.*s from exe filename.", al_str_x(addr));
 
     return true;
-def:
-    return false;
 }
 
 static struct cmv c = { 0 };
 
+#ifdef STELA_USE_PLATFORM_MAIN
+s32 stl_platform_main(u32 argc, str *argv, void *extra)
+#else
 s32 window_system_main(u32 argc, str *argv, void *extra)
+#endif
 {
-    (void)extra;
-
     bool local;
 #ifdef CAMU_SINK_ONLY
     local = argc > 1;
@@ -134,9 +137,9 @@ s32 window_system_main(u32 argc, str *argv, void *extra)
     nn_event_loop_init(&c.loop);
 
     u8 type;
-    str addr = al_str_null();
+    str addr = AL_STR_EMPTY;
     if (local) {
-#ifdef NAUNET_ON_WINDOWS
+#if defined NAUNET_ON_WINDOWS || defined NAUNET_ON_ANDROID
         type = NNWT_SOCKET_TCP;
         al_str_clone(&addr, &al_str_c("127.0.0.1"));
 #else
@@ -151,8 +154,8 @@ s32 window_system_main(u32 argc, str *argv, void *extra)
     } else {
         type = NNWT_SOCKET_TCP;
         char *SINK_IP = getenv("SINK_IP");
-        al_str_from(&addr, "");
         if (!SINK_IP || !decode_addr(&addr, &al_str_cr(SINK_IP))) {
+            local = true; // If no IP, default back to local.
             al_str_cat(&addr, &al_str_c("127.0.0.1"));
         }
     }
@@ -228,11 +231,22 @@ s32 window_system_main(u32 argc, str *argv, void *extra)
 #endif
             nn_packet_free(packet);
         }
+        if (extra) {
+            u32 start_index = *(u32 *)extra;
+            if (start_index != 0) {
+                camu_server_local_set_index(&c.server, start_index);
+            }
+        }
     }
 
     struct nn_thread thread;
     nn_thread_create(&thread, event_loop_thread, &c);
 
+#ifdef STELA_USE_PLATFORM_MAIN
+    al_str_free(&addr);
+    return 0;
+#endif
+
     while (camu_desktop_tick(&c.desktop)) {}
 
     camu_desktop_stop(&c.desktop);
@@ -251,6 +265,7 @@ out:
     return ret;
 }
 
+#ifndef STELA_USE_PLATFORM_MAIN
 static bool sigint_force = false;
 static void sigint_handler(s32 signum)
 {
@@ -314,3 +329,4 @@ s32 main(s32 argc, char *argv[])
 
     return ret;
 }
+#endif
diff --git a/src/fruits/cmv/meson.build b/src/fruits/cmv/meson.build
index ec27c81..301fa58 100644
--- a/src/fruits/cmv/meson.build
+++ b/src/fruits/cmv/meson.build
@@ -14,7 +14,10 @@ if use_tui
 endif
 
 cmv_link_args = []
-if is_windows
+if is_android
+  # https://github.com/google/ExoPlayer/issues/9933#issuecomment-1029775358
+  cmv_link_args += ['-Wl,-Bsymbolic', '-static-libstdc++']
+elif is_windows
   windows = import('windows')
   cmv_src += [windows.compile_resources('icon.rc')]
   if not is_msvc
@@ -22,4 +25,10 @@ if is_windows
   endif
 endif
 
-executable('cmv', cmv_src, dependencies: cmv_deps, c_args: cmv_args, link_args: cmv_link_args, install: true)
+if is_android
+  cmv_args += ['-DAPPLICATION_NAME="CTV"']
+  shared_library('ctv', cmv_src, dependencies: cmv_deps, c_args: cmv_args, link_args: cmv_link_args)
+else
+  cmv_args += ['-DAPPLICATION_NAME="CMV"']
+  executable('cmv', cmv_src, dependencies: cmv_deps, c_args: cmv_args, link_args: cmv_link_args, install: true)
+endif
diff --git a/src/fruits/ctv/ctv.c b/src/fruits/ctv/ctv.c
deleted file mode 100644
index 2878600..0000000
--- a/src/fruits/ctv/ctv.c
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <al/log.h>
-#include <android/log.h>
-
-#include "../../libsink/sink.h"
-#include "../../libsink/desktop.h"
-#ifdef CAMU_HAVE_FFMPEG
-#include "../../codec/ffmpeg/common.h"
-#endif
-
-#include "../common.h"
-
-struct ctv {
-    struct nn_event_loop loop;
-    struct camu_desktop desktop;
-    struct nn_thread thread;
-};
-
-static nn_thread_result NNWT_THREADCALL event_loop_thread(void *userdata)
-{
-    struct ctv *c = (struct ctv *)userdata;
-    nn_thread_set_name("event_loop");
-
-    nn_event_loop_init(&c->loop);
-
-    struct camu_sink *sink = &c->desktop.sink;
-    sink->local = true;
-
-    struct lia_prefs *prefs = &sink->prefs;
-#ifdef CAMU_HAVE_SUBTITLES
-    prefs->enabled = (1 << CAMU_STREAM_AUDIO) | (1 << CAMU_STREAM_VIDEO) | (1 << CAMU_STREAM_SUBTITLE);
-#else
-    prefs->enabled = (1 << CAMU_STREAM_AUDIO) | (1 << CAMU_STREAM_VIDEO);
-#endif
-    prefs->language.audio = CAMU_LANG_JAPANESE;
-    prefs->language.subtitles = CAMU_LANG_ENGLISH;
-
-    if (!camu_desktop_connect(&c->desktop, &al_str_c("ctv"), &c->loop, NNWT_SOCKET_TCP, &al_str_c(""), CAMU_PORT)) {
-        return 0;
-    }
-
-    nn_event_loop_run(&c->loop);
-
-    return 0;
-}
-
-static s32 log_callback(void *userdata, u8 level, char *message)
-{
-    (void)userdata;
-    (void)level;
-    __android_log_print(ANDROID_LOG_DEBUG, "CTV", "%*.*s", 0, AL_LOG_MESSAGE_SIZE, message);
-    return al_strnlen(message, AL_LOG_MESSAGE_SIZE);
-}
-
-static struct ctv c = { 0 };
-
-s32 stl_platform_main(u32 argc, str *argv)
-{
-    (void)argc;
-    (void)argv;
-
-    al_set_print(log_callback, NULL);
-
-#ifdef CAMU_HAVE_FFMPEG
-    camu_ff_common_init();
-#endif
-
-    if (!camu_desktop_open(&c.desktop, "ctv")) {
-        return 0;
-    }
-
-    nn_thread_create(&c.thread, event_loop_thread, &c);
-
-    return EXIT_SUCCESS;
-}
diff --git a/src/fruits/ctv/meson.build b/src/fruits/ctv/meson.build
deleted file mode 100644
index bf6f9e5..0000000
--- a/src/fruits/ctv/meson.build
+++ /dev/null
@@ -1,4 +0,0 @@
-ctv_src = ['ctv.c']
-ctv_deps = [common_deps, desktop]
-# https://github.com/google/ExoPlayer/issues/9933#issuecomment-1029775358
-shared_library('ctv', ctv_src, dependencies: ctv_deps, link_args: ['-Wl,-Bsymbolic', '-static-libstdc++'])
diff --git a/src/fruits/droid/ctv/app/src/main/AndroidManifest.xml b/src/fruits/droid/ctv/app/src/main/AndroidManifest.xml
index e957943..30a4d35 100644
--- a/src/fruits/droid/ctv/app/src/main/AndroidManifest.xml
+++ b/src/fruits/droid/ctv/app/src/main/AndroidManifest.xml
@@ -2,6 +2,10 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
+    <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
+    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
     <uses-feature android:name="android.software.leanback"
         android:required="false" />
     <uses-feature android:name="android.hardware.touchscreen"
@@ -27,6 +31,28 @@
             <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
         </intent-filter>
     </activity>
-    </application>
 
+    <activity-alias
+        android:name=".api.file.OpenWithActivity"
+        android:exported="true"
+        android:targetActivity="android.app.NativeActivity">
+        <meta-data
+            android:name="android.app.lib_name"
+            android:value="ctv" />
+
+        <intent-filter>
+            <action android:name="android.intent.action.VIEW" />
+            <category android:name="android.intent.category.DEFAULT" />
+            <category android:name="android.intent.category.BROWSABLE" />
+            <data android:scheme="content" />
+            <data android:scheme="file" />
+            <data android:scheme="http" />
+            <data android:mimeType="application/*" />
+            <data android:mimeType="audio/*" />
+            <data android:mimeType="image/*" />
+            <data android:mimeType="text/*" />
+            <data android:mimeType="video/*" />
+        </intent-filter>
+    </activity-alias>
+    </application>
 </manifest>
diff --git a/src/liana/client.c b/src/liana/client.c
index 2b62612..1e873c6 100644
--- a/src/liana/client.c
+++ b/src/liana/client.c
@@ -138,7 +138,7 @@ static void parse_info_packet(struct lia_client *client, struct nn_packet *packe
     nn_packet_read_str(packet, &handler);
     client->duration = nn_packet_read_u64(packet);
     collect_streams(client, packet);
-    if (client->streams.count == 0) {
+    if (!client->streams.count) {
         log_warn("Resource has no streams.");
         goto out;
     }
diff --git a/src/liana/handlers/cdio_server.c b/src/liana/handlers/cdio_server.c
index c67330d..65bd990 100644
--- a/src/liana/handlers/cdio_server.c
+++ b/src/liana/handlers/cdio_server.c
@@ -6,7 +6,7 @@
 
 #include "cdio.h"
 
-#define SECTORS_PER_PACKET 8
+#define SAMPLES_PER_PACKET 128
 
 static bool cdio_server_init(struct lia_server_handler *handler, struct cch_handle *handle)
 {
@@ -75,7 +75,8 @@ static void cdio_server_step(struct lia_server_handler *handler)
 static void cdio_server_write_packet(struct lia_server_handler *handler, struct nn_packet *packet)
 {
     struct lia_cdio_server *cdio = (struct lia_cdio_server *)handler;
-    off_t size = CDIO_CD_FRAMESIZE_RAW * SECTORS_PER_PACKET;
+    size_t bps = camu_audio_format_bytes_per_sample(&cdio->fmt) * cdio->fmt.channel_count;
+    off_t size = bps * SAMPLES_PER_PACKET;
     nn_buffer_ensure_space(&cdio->buffer, size);
     s32 ret = cch_handle_read(cdio->handle, nn_buffer_get_ptr(&cdio->buffer, 0), size);
     if (ret == CAMU_ERR_EOF) {
@@ -87,7 +88,8 @@ static void cdio_server_write_packet(struct lia_server_handler *handler, struct
     nn_packet_write_u8(packet, LIANA_PACKET_DATA);
     nn_packet_write_s32(packet, 0);
     nn_packet_write_f64(packet, cdio->pts);
-    s32 sample_count = ret / (camu_audio_format_bytes_per_sample(&cdio->fmt) * cdio->fmt.channel_count);
+    al_assert(ret % bps == 0);
+    s32 sample_count = ret / bps;
     nn_packet_write_s32(packet, sample_count);
     cdio->buffer.size = ret;
     nn_packet_write_buffer(packet, &cdio->buffer);
diff --git a/src/liana/list.c b/src/liana/list.c
index d12caab..01c2ff3 100644
--- a/src/liana/list.c
+++ b/src/liana/list.c
@@ -712,7 +712,7 @@ static void handle_clear(struct lia_list *list)
 static void run_queue(struct lia_list *list)
 {
     if (!list->cmd) {
-        if (list->command_queue.count) {
+        if (list->command_queue.count > 0) {
             al_array_pop_at(list->command_queue, 0, list->cmd);
         } else {
             return;
diff --git a/src/liana/server.c b/src/liana/server.c
index 5065425..791fe0e 100644
--- a/src/liana/server.c
+++ b/src/liana/server.c
@@ -124,7 +124,7 @@ static void free_connection(struct lia_node_connection *conn)
     struct lia_node *node = conn->node;
     al_assert(conn->handler);
     conn->handler->free(&conn->handler);
-    cch_entry_return_handle(conn->node->entry, &conn->handle);
+    cch_entry_return_handle(node->entry, &conn->handle);
     nn_packet_pool_free(&conn->pool);
     bool removed = al_array_remove(node->connections, conn);
     al_assert(removed);
@@ -272,31 +272,32 @@ static void signal_callback(void *userdata)
 
     nn_thread_join(&conn->thread);
     nn_signal_stop(&conn->signal);
-    al_array_remove(node->requests, conn);
 
     struct nn_packet_stream *stream = conn->stream;
     struct nn_packet *packet = conn->packet;
     conn->packet = NULL;
 
+    if (packet) {
+        al_array_remove(node->requests, conn);
+    }
+
     if (!packet || conn->errored) {
         conn->handler->free(&conn->handler);
         cch_entry_return_handle(node->entry, &conn->handle);
     }
 
-    if (!packet) {
-        // Connection was closed before init was done.
+    if (!packet) { // Connection was closed before init was done.
+        al_free(conn);
         if (should_free_node(node)) {
             free_node(node);
         }
         nn_packet_stream_free(stream);
         al_free(stream);
-        al_free(conn);
     } else if (conn->errored) {
         // We must return the packet before disconnecting.
         nn_packet_stream_return_packet(stream, packet);
-        al_free(conn);
-        conn = NULL;
         demote_and_disconnect_stream(server, stream);
+        al_free(conn);
     } else {
         conn->id = get_incremental_id(server);
         al_array_push(node->connections, conn);
@@ -337,10 +338,12 @@ static struct lia_node_connection *get_connection_from_id(struct lia_node *node,
 static void pre_init_connection_closed_callback(void *userdata, struct nn_packet_stream *stream)
 {
     struct lia_node_connection *conn = (struct lia_node_connection *)userdata;
+    struct lia_node *node = conn->node;
     struct nn_packet *packet = conn->packet;
     // Checked in signal_callback and will signal to cleanup the connection.
     conn->packet = NULL;
     nn_packet_stream_return_packet(stream, packet);
+    al_array_remove(node->requests, conn);
 }
 
 static void packet_callback(void *userdata, struct nn_packet_stream *stream, struct nn_packet *packet)
@@ -439,6 +442,10 @@ static nn_thread_result NNWT_THREADCALL init_duration_thread(void *userdata)
 {
     struct lia_node *node = (struct lia_node *)userdata;
     nn_thread_set_name("liana_init_dur");
+#if 0 // This is really bad for large resources and is just for testing.
+    lia_prepare_visual_data(&node->handle, &node->visual);
+    cch_handle_seek(&node->handle, 0, SEEK_SET);
+#endif
     if (!node->handler->init(node->handler, &node->handle)) {
         node->errored = true;
     } else {
diff --git a/src/liana/server.h b/src/liana/server.h
index bafe95b..ec6f82e 100644
--- a/src/liana/server.h
+++ b/src/liana/server.h
@@ -7,6 +7,8 @@
 
 #include "../cache/entry.h"
 
+#include "process.h"
+
 //#define LIANA_SERVER_LOOP
 
 struct lia_node_connection {
@@ -46,6 +48,8 @@ struct lia_node {
     struct cch_handle handle;
     struct nn_thread thread;
     struct nn_signal signal;
+    // @TODO: This should probably be on camu_resource instead.
+    struct lia_visual_data visual;
 };
 
 struct lia_server {
diff --git a/src/liana/vcr.c b/src/liana/vcr.c
index f9dad7b..3a61e32 100644
--- a/src/liana/vcr.c
+++ b/src/liana/vcr.c
@@ -26,6 +26,7 @@ enum {
 enum {
     VCR_TRACK_RUNNING = 0,
     VCR_TRACK_STOPPED,
+    VCR_TRACK_ERRORED,
     VCR_TRACK_CLOSED
 };
 
@@ -131,8 +132,8 @@ static nn_thread_result NNWT_THREADCALL vcr_track_thread(void *userdata)
     nn_thread_set_priority(NNWT_THREAD_SCHED_FIFO, 32);
     struct lia_vcr_track *track = (struct lia_vcr_track *)userdata;
     struct lia_vcr *vcr = track->vcr;
-    const char thread_name[16] = "\0"; // 16 = limit.
-    al_snprintf((char *)thread_name, sizeof(thread_name), "vcr:%hu_%d", vcr->node_id, track->stream->index);
+    char thread_name[16] = "\0"; // 16 = limit.
+    al_snprintf(thread_name, sizeof(thread_name), "vcr:%hu_%d", vcr->node_id, track->stream->index);
     nn_thread_set_name(thread_name);
 
     bool corked;
@@ -177,12 +178,13 @@ static nn_thread_result NNWT_THREADCALL vcr_track_thread(void *userdata)
                 return_entire_cache(track);
                 track->cache.disabled = true;
                 nn_packet_cache_unlock(&track->cache);
+                // Let flush()/close() know we forcefully exited the thread.
+                track->state = VCR_TRACK_ERRORED;
                 nn_mutex_unlock(&track->lock);
                 return 0;
             }
 
-            if (!packet) {
-                // Wait on EOF.
+            if (!packet) { // Wait on EOF.
                 track->state = VCR_TRACK_STOPPED;
             }
 
@@ -410,6 +412,7 @@ void lia_vcr_set_buffered(struct lia_vcr_track *track)
 // Meaning track->lock will be held.
 void lia_vcr_cork(struct lia_vcr_track *track)
 {
+    al_assert(track->state != VCR_TRACK_ERRORED);
     track->state = VCR_TRACK_STOPPED;
 }
 
@@ -422,6 +425,9 @@ void lia_vcr_uncork(struct lia_vcr_track *track)
     //    being held by flush(). flush() sets the state to CLOSED and signals the
     //    cond. Now nn_cond_is_waiting() is false at the point uncork() acquires the lock.
     nn_mutex_lock(&track->lock);
+    // If a buffer is running under MARK_LOW, it will be continuously trying to uncork()
+    // the track. Meaning an erroring handle_packet() could happen at the same time as
+    // an uncork(). Causing track->state to be ERRORED after we acquire the lock here.
     if (track->state != VCR_TRACK_STOPPED) {
         nn_mutex_unlock(&track->lock);
         return;
diff --git a/src/libsink/desktop.c b/src/libsink/desktop.c
index e9ccedb..2707f34 100644
--- a/src/libsink/desktop.c
+++ b/src/libsink/desktop.c
@@ -127,12 +127,11 @@ static void log_sink_status(struct camu_desktop *c)
 
     u64 pts = camu_clock_get_last_pts(&current->clock) * 1000000u;
     u64 duration = current->client.duration;
-    pts = MIN(duration, pts);
     bool paused = current->paused;
 
     camu_sink_return_current(sink);
 
-    u64 remaining = duration - pts;
+    u64 remaining = duration - MIN(pts, duration);
     if (remaining == 0) {
         goto notplaying;
     }
@@ -162,14 +161,17 @@ static void screen_callback(void *userdata, u8 op, void *opaque)
             volume = (c->mixer.volume == 0.f) ? 1.f : 0.f;
         }
         camu_mixer_set_volume(&c->mixer, volume);
-        log_info("Volume: %f.", volume);
+        *(f32 *)opaque = volume;
         break;
     }
     case CAMU_SCREEN_OFFSET_VOLUME: {
         f32 volume = camu_mixer_offset_volume(&c->mixer, *(f32 *)opaque);
-        log_info("Volume: %f.", volume);
+        *(f32 *)opaque = volume;
         break;
     }
+    case CAMU_SCREEN_ADD:
+        camu_sink_add(&c->sink, (str *)opaque);
+        break;
     case CAMU_SCREEN_SKIP:
         camu_sink_skip(&c->sink, *(s32 *)opaque);
         break;
@@ -189,6 +191,9 @@ static void screen_callback(void *userdata, u8 op, void *opaque)
         camu_sink_shuffle(&c->sink);
         break;
     case CAMU_SCREEN_STATUS:
+        camu_sink_status(&c->sink, (struct camu_osd *)opaque);
+        break;
+   case CAMU_SCREEN_PRINT:
         log_sink_status(c);
         break;
 #ifdef CAMU_SCREEN_DEBUG_KEY
diff --git a/src/libsink/sink.c b/src/libsink/sink.c
index 783f242..5f61bd4 100644
--- a/src/libsink/sink.c
+++ b/src/libsink/sink.c
@@ -3,6 +3,7 @@
 #include <al/log.h>
 #include <al/random.h>
 #include <nnwt/multiplex.h>
+#include <nnwt/time.h>
 
 #include "../server/common.h"
 #include "../buffer/common.h"
@@ -49,6 +50,7 @@ enum {
     EJECT_ENTRY,
     CLOSE,
     // List actions.
+    ADD,
     SKIP,
     TOGGLE_PAUSE,
     SEEK,
@@ -57,6 +59,13 @@ enum {
     END
 };
 
+// Status reporting.
+enum {
+    NOTIFY_EMPTY = 1,
+    NOTIFY_NOT_EMPTY = 1 << 1,
+    NOTIFY_SEEK = 1 << 2
+};
+
 // Number of entries to keep buffered at one time.
 #define ENTRY_MAX_AGE 4
 #define SINK_LRU_MAX UINT16_MAX
@@ -375,6 +384,17 @@ static void handle_sink_cmd(struct camu_sink *sink, struct camu_sink_cmd *cmd)
         sink->callback(sink->userdata, CAMU_SINK_EXIT, 0, NULL);
         return;
     }
+    case ADD: {
+        if (!sink->connected) return;
+        struct nn_packet *packet = nn_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION);
+        nn_packet_write_str(packet, &sink->default_list);
+        nn_packet_write_u8(packet, CAMU_LIST_ADD);
+        nn_packet_write_str(packet, (str *)cmd->v.p);
+        al_str_free((str *)cmd->v.p);
+        al_free(cmd->v.p);
+        nn_rpc_connection_command(sink->conn, packet, NULL, NULL);
+        break;
+    }
     case SKIP: {
         if (!sink->connected) return;
         struct camu_sink_entry *entry = (struct camu_sink_entry *)cmd->opaque;
@@ -719,12 +739,18 @@ static void switch_to(struct camu_sink *sink, struct camu_sink_entry *target)
 
     if (stop_video) {
         queue_cmd(sink, CMD(STOP, .v.u = CAMU_SINK_VIDEO));
-        if (dangling_target || VIDEO_ENDED_OR_EMPTY(target)) {
+        // Refresh on VIDEO_ENDED_OR_EMPTY(target) should be covered by after_add_entry().
+        if (dangling_target) {
             refresh_video_output(sink);
         }
     }
 
     sink->current = dangling_target ? NULL : target;
+
+    if (sink->current) {
+        sink->notify_status |= NOTIFY_NOT_EMPTY;
+        nn_timer_again(&sink->empty_timer);
+    }
 }
 
 static void pause_and_swap_to(struct camu_sink *sink, struct camu_sink_entry *target, u64 at)
@@ -1330,6 +1356,15 @@ static struct camu_sink_entry *get_entry_from_id(struct camu_sink *sink, u64 id)
     return NULL;
 }
 
+static void unset_current(struct camu_sink *sink)
+{
+    struct camu_sink_entry *current = sink->current;
+    nn_mutex_unlock(&sink->lock);
+    if (current) {
+        maybe_disconnect_entry(current);
+    }
+}
+
 static bool set_command_callback(void *userdata, struct nn_rpc_connection *conn,
     struct nn_packet *packet, struct nn_packet *rpacket)
 {
@@ -1339,11 +1374,7 @@ static bool set_command_callback(void *userdata, struct nn_rpc_connection *conn,
     u8 op = nn_packet_read_u8(packet);
     if (op == LIANA_SINK_UNSET) {
         nn_mutex_lock(&sink->lock);
-        struct camu_sink_entry *current = sink->current;
-        nn_mutex_unlock(&sink->lock);
-        if (current) {
-            maybe_disconnect_entry(current);
-        }
+        unset_current(sink);
         nn_mutex_lock(&sink->lock);
         goto out;
     }
@@ -1378,6 +1409,13 @@ static bool set_command_callback(void *userdata, struct nn_rpc_connection *conn,
     // Don't lock before client_connect() or we could deadlock in CLIENT_CLOSED on a failed socket_connect().
     nn_mutex_lock(&sink->lock);
 
+    // lia_client_connect() can fail and call connection_closed_callback() in-line. Meaning this entry
+    // could already be disconnected here.
+    if (!al_array_contains(sink->entries, entry)) {
+        unset_current(sink);
+        goto out;
+    }
+
     struct camu_sink_entry *current = sink->current;
 
     if (op == LIANA_SINK_BUFFER) {
@@ -1494,24 +1532,30 @@ static bool pause_command_callback(void *userdata, struct nn_rpc_connection *con
     switch (pause) {
     case LIANA_PAUSE_PAUSE: {
         entry->paused = true;
-        camu_clock_pause(&entry->clock, at);
+        if (camu_clock_pause(&entry->clock, at)) {
+            if (entry == sink->current) {
+                queue_cmd(sink, CMD(STOP, .v.u = CAMU_SINK_VIDEO));
+            }
+        }
         log_info("Clock paused.");
         // Audio will be stopped in a BUFFER_PAUSED callback.
-        // Video will be stopped in a CLOCK_PAUSED callback.
+        // Video will be stopped above or in a CLOCK_PAUSED callback.
         break;
     }
     case LIANA_PAUSE_RESUME: {
         entry->paused = false;
         camu_clock_resume(&entry->clock, at);
         log_info("Clock resumed.");
-        if (!VIDEO_ENDED_OR_EMPTY(entry) && !VIDEO_IS_STATIC(entry)) {
-            queue_cmd(sink, CMD(START, .v.u = CAMU_SINK_VIDEO));
-        }
-        if (!AUDIO_ENDED_OR_EMPTY(entry)) {
-            if (!sink->local) {
-                camu_audio_buffer_resync(&entry->audio.buf);
+        if (entry == sink->current) {
+            if (!VIDEO_ENDED_OR_EMPTY(entry) && !VIDEO_IS_STATIC(entry)) {
+                queue_cmd(sink, CMD(START, .v.u = CAMU_SINK_VIDEO));
+            }
+            if (!AUDIO_ENDED_OR_EMPTY(entry)) {
+                if (!sink->local) {
+                    camu_audio_buffer_resync(&entry->audio.buf);
+                }
+                queue_cmd(sink, CMD(START, .v.u = CAMU_SINK_AUDIO));
             }
-            queue_cmd(sink, CMD(START, .v.u = CAMU_SINK_AUDIO));
         }
         break;
     }
@@ -1542,6 +1586,7 @@ static bool seek_command_callback(void *userdata, struct nn_rpc_connection *conn
     entry->sequence = sequence;
     log_trace("seek("ENTRY_FMT", %.2f), reset_token: %u.", ENTRY_ARG(entry), pos / 1000000.0, reset_token);
     entry->reset_token = reset_token;
+    sink->notify_status |= NOTIFY_SEEK;
     nn_mutex_unlock(&sink->lock);
     // The rest of the seek is handled in CLIENT_REMOVE_BUFFERS/RESUME_AT/RECONNECTED.
     lia_client_seek(&entry->client, pos, at);
@@ -1589,6 +1634,7 @@ static void connection_callback(void *userdata, struct nn_rpc_connection *conn)
     if (sink->conn) al_assert(sink->conn == conn);
     sink->conn = conn;
     sink->connected = true;
+    refresh_video_output(sink); // For OSD.
     sink->connection_number = al_u16_inc_wrap(sink->connection_number);
     if (sink->connection_number == 0) sink->connection_number = 1;
     identify_on_connection(sink);
@@ -1608,6 +1654,9 @@ static void reconnect_timer_callback(void *userdata, struct nn_timer *timer)
 static void connection_closed_callback(void *userdata, struct nn_rpc_connection *conn)
 {
     struct camu_sink *sink = (struct camu_sink *)userdata;
+    // @TODO: This is broken for an immediately failing reconnect().
+    //  If the nn_rpc_reconnect() in this function fails and recurses on connection_closed_callback(),
+    //  sink->conn will be NULL and we will not attempt to reconnect.
     bool reconnect = sink->conn != NULL;
     bool disconnected = sink->conn && sink->connection_number > 0;
     if (sink->conn) {
@@ -1628,6 +1677,18 @@ static void connection_closed_callback(void *userdata, struct nn_rpc_connection
     }
 }
 
+static void empty_timer_callback(void *userdata, struct nn_timer *timer)
+{
+    struct camu_sink *sink = (struct camu_sink *)userdata;
+    (void)timer;
+    if (!sink->current) {
+        sink->notify_status = NOTIFY_EMPTY;
+        refresh_video_output(sink);
+        nn_timer_stop(&sink->empty_timer);
+    }
+    nn_timer_set_repeat(&sink->empty_timer, NNWT_TS_FROM_USEC(1000000));
+}
+
 bool camu_sink_init(struct camu_sink *sink, struct nn_event_loop *loop,
     struct camu_mixer *mixer, struct camu_renderer *renderer)
 {
@@ -1647,6 +1708,10 @@ bool camu_sink_init(struct camu_sink *sink, struct nn_event_loop *loop,
     sink->suspended = NULL;
     al_array_init(sink->previous);
     al_array_init(sink->entries);
+    nn_timer_init(&sink->empty_timer, sink->loop, empty_timer_callback, sink);
+    nn_timer_set_repeat(&sink->empty_timer, NNWT_TS_FROM_USEC(100000));
+    nn_timer_again(&sink->empty_timer);
+    sink->notify_status = 0;
     // Start high to exercise the wrapping path.
     sink->lru = SINK_LRU_MAX - al_random_int(0, ENTRY_MAX_AGE);
     mixer->callback = mixer_callback;
@@ -1690,6 +1755,13 @@ void camu_sink_return_current(struct camu_sink *sink)
     nn_mutex_unlock(&sink->lock);
 }
 
+void camu_sink_add(struct camu_sink *sink, str *path)
+{
+    str *copy = al_alloc_object(str);
+    al_str_clone(copy, path);
+    queue_cmd(sink, CMD(ADD, .v.p = copy));
+}
+
 void camu_sink_skip(struct camu_sink *sink, s32 n)
 {
     nn_mutex_lock(&sink->lock);
@@ -1721,7 +1793,9 @@ void camu_sink_seek(struct camu_sink *sink, void *value, u8 mode)
         pts = camu_clock_get_last_pts(&current->clock);
     }
     nn_mutex_unlock(&sink->lock);
-    if (!current || duration == 0) return;
+    if (!current || duration == 0) {
+        return;
+    }
     struct camu_sink_cmd cmd = {
         .op = SEEK,
         .opaque = current
@@ -1735,7 +1809,7 @@ void camu_sink_seek(struct camu_sink *sink, void *value, u8 mode)
     case CAMU_SEEK_RELATIVE: {
         f64 offset = *(f64 *)value;
         pts = MAX(pts + offset, 0.0);
-        cmd.v.u = (u64)(pts * 1000000);
+        cmd.v.u = (u64)(pts * 1000000.0);
         break;
     }
     case CAMU_SEEK_PERCENT: {
@@ -1758,6 +1832,45 @@ void camu_sink_shuffle(struct camu_sink *sink)
     queue_cmd(sink, CMD(SHUFFLE));
 }
 
+void camu_sink_status(struct camu_sink *sink, struct camu_osd *osd)
+{
+    nn_mutex_lock(&sink->lock);
+    struct camu_sink_entry *current = sink->current;
+    osd->connecting = !sink->connected;
+    if (sink->notify_status & NOTIFY_EMPTY) {
+        sink->notify_status &= ~NOTIFY_EMPTY;
+        osd->show = true;
+        osd->shown_for |= CAMU_OSD_EMPTY;
+    }
+    if (sink->notify_status & NOTIFY_NOT_EMPTY) {
+        sink->notify_status &= ~NOTIFY_NOT_EMPTY;
+        if (osd->shown_for & CAMU_OSD_EMPTY) {
+            osd->shown_for &= ~CAMU_OSD_EMPTY;
+            osd->show = false;
+        }
+    }
+    if (sink->notify_status & NOTIFY_SEEK) {
+        sink->notify_status &= ~NOTIFY_SEEK;
+        if (!osd->show) {
+            osd->flash = CAMU_OSD_FLASH_FOR(0.75);
+        }
+    }
+    nn_mutex_unlock(&sink->lock);
+    if (current) {
+        osd->paused = camu_clock_is_user_paused(&current->clock);
+        bool armed_for_pause = false;
+        osd->pts = camu_clock_get_pts(&current->clock, 0.0, false, &armed_for_pause);
+        if (CAMU_PTS_CONSIDER_PAUSED(osd->pts)) {
+            osd->pts = camu_clock_get_last_pts(&current->clock);
+        }
+        osd->duration = current->client.duration;
+    } else {
+        osd->paused = false;
+        osd->pts = 0.0;
+        osd->duration = 0;
+    }
+}
+
 void camu_sink_stop(struct camu_sink *sink)
 {
     queue_cmds(sink, 3,
@@ -1775,6 +1888,7 @@ void camu_sink_close(struct camu_sink *sink)
         sink->conn = NULL; // Signal to connection_closed_callback() we're done.
         nn_rpc_conn_disconnect(conn);
     }
+    nn_timer_stop(&sink->empty_timer);
     struct camu_sink_entry *entry;
     al_array_foreach_rev(sink->entries, i, entry) {
         al_array_remove_at(sink->entries, i);
diff --git a/src/libsink/sink.h b/src/libsink/sink.h
index acb6a51..6000b4f 100644
--- a/src/libsink/sink.h
+++ b/src/libsink/sink.h
@@ -8,6 +8,7 @@
 
 #include "../util/queue.h"
 #include "../liana/client.h"
+#include "../screen/screen.h"
 #include "../buffer/clock.h"
 #include "../buffer/audio.h"
 #ifndef CAMU_SINK_NO_VIDEO
@@ -70,7 +71,7 @@ struct camu_sink_entry {
 
 struct camu_sink_cmd {
     u8 op;
-    union { s64 i; u64 u; f64 f; } v;
+    union { s64 i; u64 u; f64 f; void *p; } v;
     void *opaque;
 };
 
@@ -95,6 +96,8 @@ struct camu_sink {
     struct camu_sink_entry *suspended;
     array(struct camu_sink_entry *) previous;
     array(struct camu_sink_entry *) entries;
+    struct nn_timer empty_timer;
+    u8 notify_status;
     u16 lru;
     struct {
         u8 state;
@@ -115,11 +118,13 @@ bool camu_sink_init(struct camu_sink *sink, struct nn_event_loop *loop,
 bool camu_sink_connect(struct camu_sink *sink, str *name, u8 type, str *addr, u16 port);
 struct camu_sink_entry *camu_sink_get_current(struct camu_sink *sink);
 void camu_sink_return_current(struct camu_sink *sink);
+void camu_sink_add(struct camu_sink *sink, str *path);
 void camu_sink_skip(struct camu_sink *sink, s32 n);
 void camu_sink_toggle_pause(struct camu_sink *sink);
 void camu_sink_seek(struct camu_sink *sink, void *value, u8 mode);
 void camu_sink_reseek(struct camu_sink *sink);
 void camu_sink_shuffle(struct camu_sink *sink);
+void camu_sink_status(struct camu_sink *sink, struct camu_osd *osd);
 void camu_sink_stop(struct camu_sink *sink);
 void camu_sink_close(struct camu_sink *sink);
 void camu_sink_free(struct camu_sink *sink);
diff --git a/src/render/renderer.h b/src/render/renderer.h
index 0eae5cb..ffd590e 100644
--- a/src/render/renderer.h
+++ b/src/render/renderer.h
@@ -48,7 +48,7 @@ struct camu_renderer {
         VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL (*get_vk_proc_address)(VkInstance, const char *),
         VkResult (*vk_create_surface)(void *, VkInstance, VkSurfaceKHR *),
         VkResult (*vk_destroy_surface)(VkInstance, VkSurfaceKHR),
-        const char *const *(*vk_get_extensions)(u32 *),
+        const char * const *(*vk_get_extensions)(u32 *),
 #elif defined STELA_API_DX11
         HWND win32_window,
 #elif defined STELA_API_OPENGL
diff --git a/src/render/renderer_libplacebo.c b/src/render/renderer_libplacebo.c
index d6f95a8..8c28162 100644
--- a/src/render/renderer_libplacebo.c
+++ b/src/render/renderer_libplacebo.c
@@ -2,15 +2,21 @@
 //#define AL_LOG_ENABLE_TRACE
 #include <al/log.h>
 #include <al/lib.h>
+#include <al/math.h>
 #include <nnwt/file.h>
 #include <nnwt/time.h>
+#include <libplacebo/shaders.h>
 
 #include "../screen/screen.h"
 #include "../util/color_palette.h"
+#include "../util/print_time.h"
 
 #include "renderer_libplacebo.h"
 #include "queue_libplacebo.h"
 
+#include "shaders/osd_header.h"
+#include "shaders/osd.h"
+#include "shaders/osd_binds.h"
 #include "shaders/vr_video.h"
 
 #ifdef AL_DEBUG
@@ -21,14 +27,18 @@
 #endif
 
 #define CRT_BACKGROUND
-#define CRT_BACKGROUND_COLOR (1.f / 7.5f)
-#define CRT_BACKGROUND_COLOR_ON (0.025f)
+#define CRT_BACKGROUND_COLOR(c4) do { \
+    c4[0] = 0.1333f; c4[1] = 0.1333f; c4[2] = 0.1333f; \
+} while (0)
+#define CRT_BACKGROUND_COLOR_ON(lr, c4) do { \
+    if (lr->params.background != PL_CLEAR_SKIP) { \
+        c4[0] = 0.025f; c4[1] = 0.025f; c4[2] = 0.025f; \
+    } else { \
+        c4[0] = 0.f;    c4[1] = 0.f;    c4[2] = 0.f; \
+    } \
+} while (0)
 
-#ifdef CRT_BACKGROUND
-static f32 clear_color[4] = { CRT_BACKGROUND_COLOR, CRT_BACKGROUND_COLOR, CRT_BACKGROUND_COLOR, 1.f };
-#else
 static f32 clear_color[4] = { 0.f, 0.f, 0.f, 1.f };
-#endif
 
 static struct pl_render_params default_params;
 
@@ -62,13 +72,14 @@ static void renderer_lp_set(struct camu_renderer *renderer, u8 option, u8 value)
 {
     struct camu_renderer_lp *lr = (struct camu_renderer_lp *)renderer;
     switch (option) {
-    case CAMU_RENDERER_FULLSCREEN:
+    case CAMU_RENDERER_FULLSCREEN: {
 #ifdef STELA_API_DX11
         IDXGISwapChain *d3d_swapchain = pl_d3d11_swapchain_unwrap(lr->swapchain);
         IDXGISwapChain_SetFullscreenState(d3d_swapchain, value, NULL);
         IDXGISwapChain_Release(d3d_swapchain);
 #endif
         break;
+    }
     case CAMU_RENDERER_SCALING:
         switch (value) {
         case CAMU_SCALING_DEFAULT:
@@ -106,7 +117,7 @@ static void log_callback(void *userdata, enum pl_log_level level, const char *me
         // will be shot anyway so allow it.
         log_info(message);
     } else {
-        log_debug(message);
+        log_info(message);
     }
 }
 
@@ -136,7 +147,7 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, u32 *wid
     VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL (*get_vk_proc_address)(VkInstance, const char *),
     VkResult (*vk_create_surface)(void *, VkInstance, VkSurfaceKHR *),
     VkResult (*vk_destroy_surface)(VkInstance, VkSurfaceKHR),
-    const char *const *(*vk_get_extensions)(u32 *),
+    const char * const *(*vk_get_extensions)(u32 *),
 #elif defined STELA_API_DX11
     HWND win32_window,
 #elif defined STELA_API_OPENGL
@@ -174,7 +185,7 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, u32 *wid
     lr->vk_destroy_surface = vk_destroy_surface;
 
     u32 num;
-    const char *const *extensions = vk_get_extensions(&num);
+    const char * const *extensions = vk_get_extensions(&num);
     lr->vk_inst = pl_vk_inst_create(lr->logger, pl_vk_inst_params(
         .debug = RENDERER_DEBUG,
         .get_proc_addr = get_vk_proc_address,
@@ -229,7 +240,7 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, u32 *wid
     // https://learn.microsoft.com/en-us/windows/win32/api/dxgi/ne-dxgi-dxgi_swap_chain_flag
     // https://learn.microsoft.com/en-us/windows/win32/api/dxgi/ne-dxgi-dxgi_swap_effect
     char *FLIP = getenv("SINK_DXGI_FLIP");
-    if (!FLIP) FLIP = "0";
+    if (!FLIP) FLIP = "1";
     lr->swapchain = pl_d3d11_create_swapchain(lr->d3d11, pl_d3d11_swapchain_params(
         .window = win32_window,
         .blit = al_strscmp(FLIP, "0") == 0,
@@ -280,6 +291,22 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, u32 *wid
     log_info("Using OpenGL.");
 #endif
 
+#ifdef USE_LIBPLACEBO_CACHE
+    lr->cache = pl_cache_create(pl_cache_params(
+        .log = lr->logger,
+        .max_total_size = MB(50)
+    ));
+    pl_gpu_set_cache(lr->gpu, lr->cache);
+    FILE *cache_file = fopen("sink.cache", "rb");
+    if (cache_file) {
+        pl_cache_load_file(lr->cache, cache_file);
+        //p->cache_sig = pl_cache_signature(p->cache);
+        fclose(cache_file);
+    }
+#endif
+
+    lr->dispatch = pl_dispatch_create(lr->gpu->log, lr->gpu);
+
     lr->renderer = pl_renderer_create(lr->logger, lr->gpu);
 
     pl_swapchain_resize_compat(lr->swapchain, width, height);
@@ -291,6 +318,7 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, u32 *wid
 
     al_memset(&lr->params, 0, sizeof(struct pl_render_params));
     lr->params = default_params;
+
     lr->params.deband_params = NULL;
     //lr->params.frame_mixer = NULL;
 
@@ -302,16 +330,79 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, u32 *wid
     // Prioritize a more consistent image.
     lr->params.correct_subpixel_offsets = true;
 
-    //lr->params.distort_params = pl_distort_params(.unscaled = false);
-    lr->vr_emulation_hook[0] = pl_mpv_user_shader_parse(lr->gpu, vr_video_shader, sizeof(vr_video_shader) - 1);
-    /*
+    lr->osd.vars[0].var = pl_var_uvec2("screen");
+    lr->osd.vars[1].var = pl_var_uint("scale");
+    lr->osd.vars[2].var = pl_var_float("time");
+    lr->osd.vars[3].var = pl_var_uint("show_osd");
+    lr->osd.vars[4].var = pl_var_uint("connecting");
+    lr->osd.vars[5].var = pl_var_uint("paused");
+    lr->osd.vars[6].var = pl_var_uint("bar_mode");
+    lr->osd.vars[7].var = pl_var_float("bar");
+    lr->osd.vars[8].var = pl_var_float("dbar");
+    lr->osd.vars[9].var = pl_var_float("bbar");
+    lr->osd.vars[10].var = pl_var_uint("show_hour");
+    lr->osd.vars[11].var = pl_var_uint("negative");
+    static const char num_names[9][6] = {
+        "num1",  "num2",  "num3",  "num4",
+        "num5",  "num6",  "num7",  "num8",
+        "num9"
+    };
+    for (u32 i = 0; i < 9; i++) {
+        lr->osd.vars[12 + i].var = pl_var_uint(num_names[i]);
+    }
+    for (u32 i = 0; i < 21; i++) {
+        lr->osd.vars[i].dynamic = true;
+    }
+
+    lr->osd.attribs[0] = (struct pl_vertex_attrib){
+        .name = "pos",
+        .offset = 0,
+        .fmt = pl_find_vertex_fmt(lr->gpu, PL_FMT_FLOAT, 2)
+    };
+    lr->osd.attribs[1] = (struct pl_vertex_attrib){
+        .name = "coord",
+        .offset = sizeof(f32) * 2,
+        .fmt = pl_find_vertex_fmt(lr->gpu, PL_FMT_FLOAT, 2)
+    };
+
+    al_memcpy(lr->osd.vertices, (f32[]){
+        1.f,  1.f, 1.f, 1.f,
+       -1.f, -1.f, 0.f, 0.f,
+       -1.f,  1.f, 0.f, 1.f,
+       -1.f, -1.f, 0.f, 0.f,
+        1.f, -1.f, 1.f, 0.f,
+        1.f,  1.f, 1.f, 1.f,
+    }, sizeof(f32) * 24);
+
+    lr->osd.prelude = osd_header_shader;
+    lr->osd.header = osd_shader;
+    lr->osd.binds = osd_binds_shader;
+#if 0
     struct nn_file file;
-    if (nn_file_open(&file, &al_str_c(""), 0)) {
+    if (nn_file_open(&file, &al_str_c("../src/render/shaders/osd_header.glsl"), 0)) {
+        char *c_str;
+        nn_file_read_as_c_str(&file, &c_str);
+        lr->osd.prelude = c_str;
+        nn_file_close(&file);
+    }
+    if (nn_file_open(&file, &al_str_c("../src/render/shaders/osd.glsl"), 0)) {
         char *c_str;
-        size_t length = nn_file_read_as_c_str(&file, &c_str);
-        const struct pl_hook *hook = pl_mpv_user_shader_parse(lr->gpu, (const char *)c_str, length);
+        nn_file_read_as_c_str(&file, &c_str);
+        lr->osd.header = c_str;
+        nn_file_close(&file);
     }
-    */
+    if (nn_file_open(&file, &al_str_c("../src/render/shaders/osd_binds.glsl"), 0)) {
+        char *c_str;
+        nn_file_read_as_c_str(&file, &c_str);
+        lr->osd.binds = c_str;
+        nn_file_close(&file);
+    }
+#endif
+    lr->osd.tick_time = -1.0;
+    lr->osd.logged_fail = false;
+
+    lr->vr_init_failed = false;
+    lr->vr_emulation_hook[0] = NULL;
 
 #ifdef CAMU_HAVE_FFMPEG
     lr->r.get_buffer2 = pl_get_buffer2;
@@ -385,6 +476,125 @@ static inline intptr_t float_64_hash(f64 value)
     return hash;
 }
 
+#define ROUND_SECONDS(h, m, s, n) do { \
+    if (n >= 50) { \
+        if (s == 59) { \
+            if (m == 59) { \
+                h++; \
+                m = 0; \
+            } else m++; \
+            s = 0; \
+        } else s++; \
+    } \
+} while (0)
+
+static inline bool render_osd(struct camu_renderer_lp *lr, struct camu_screen *scr)
+{
+    f64 duration = scr->osd.duration / 1000000.0;
+    f32 bar, dbar, bbar;
+    f32 progress = ((duration != 0) ? scr->osd.pts / duration : 0.f);
+    if (scr->osd.bar_mode != CAMU_OSD_BAR_VOLUME) {
+        dbar = progress;
+        bbar = dbar; // @TODO: Should be buffered, once that's supported in the VCR.
+    } else {
+        dbar = 0.f;
+        bbar = 0.f;
+    }
+    bar = (scr->osd.bar_mode == CAMU_OSD_BAR_PROGRESS) ? progress : scr->osd.bar;
+    lr->osd.screen_size[0] = scr->width;
+    lr->osd.screen_size[1] = scr->height;
+    lr->osd.vars[0].data = lr->osd.screen_size;
+    u32 scale = 1;
+    lr->osd.vars[1].data = &scale;
+    f64 tick = nn_get_tick();
+    if (lr->osd.tick_time == -1.0) lr->osd.tick_time = tick;
+    lr->osd.time = (f32)(tick - lr->osd.tick_time);
+    lr->osd.vars[2].data = &lr->osd.time;
+    lr->osd.vars[3].data = &scr->osd.show;
+    lr->osd.vars[4].data = &scr->osd.connecting;
+    lr->osd.vars[5].data = &scr->osd.paused;
+    lr->osd.vars[6].data = &scr->osd.bar_mode;
+    lr->osd.vars[7].data = &bar;
+    lr->osd.vars[8].data = &dbar;
+    lr->osd.vars[9].data = &bbar;
+    u32 hours1, minutes1, seconds1, hundredths;
+    u32 show_hour;
+    show_hour = camu_split_time(scr->osd.duration, &hours1, &minutes1, &seconds1, &hundredths);
+    ROUND_SECONDS(hours1, minutes1, seconds1, hundredths);
+    lr->osd.vars[10].data = &show_hour;
+    u32 negative;
+    negative = scr->osd.pts < 0.0f;
+    lr->osd.vars[11].data = &negative;
+    lr->osd.vars[15].data = &hours1;
+    lr->osd.vars[16].data = &minutes1;
+    lr->osd.vars[17].data = &seconds1;
+    u32 hours2, minutes2, seconds2;
+    camu_split_time(fabs(scr->osd.pts) * 1000000u, &hours2, &minutes2, &seconds2, &hundredths);
+    // The trade-off of rounding PTS is that if we do, second 0 will be shown for only half a second.
+    // If we don't, more noticeably, PTS will never equal duration if duration rounds up.
+    // There's also the option of not rounding either.
+    ROUND_SECONDS(hours2, minutes2, seconds2, hundredths);
+    lr->osd.vars[12].data = &hours2;
+    lr->osd.vars[13].data = &minutes2;
+    lr->osd.vars[14].data = &seconds2;
+    u32 zero = 0;
+    lr->osd.vars[18].data = &zero;
+    lr->osd.vars[19].data = &zero;
+    lr->osd.vars[20].data = &zero;
+    if (scr->osd.bar_mode == CAMU_OSD_BAR_SEEK) {
+        u32 hours3, minutes3, seconds3;
+        camu_split_time(fabs(duration * bar) * 1000000u, &hours3, &minutes3, &seconds3, &hundredths);
+        ROUND_SECONDS(hours3, minutes3, seconds3, hundredths);
+        lr->osd.vars[18].data = &hours3;
+        lr->osd.vars[19].data = &minutes3;
+        lr->osd.vars[20].data = &seconds3;
+    } else {
+        f64 whole = floor(bar);
+        f64 frac = (bar - whole) * 100.0;
+        u32 num1, num2;
+        num1 = (u32)whole;
+        num2 = (u32)round(frac);
+        lr->osd.vars[19].data = &num1;
+        lr->osd.vars[20].data = &num2;
+    }
+
+    lr->osd.sh = pl_dispatch_begin(lr->dispatch);
+    pl_shader_custom(lr->osd.sh, &(struct pl_custom_shader){
+        .description = "osd",
+        .prelude = lr->osd.prelude,
+        .header = scr->osd.show_binds ? lr->osd.binds : lr->osd.header,
+        .body = "color = (show_osd == 0u) ? vec4(0.) : draw_osd();",
+        .output = PL_SHADER_SIG_COLOR,
+        .num_variables = 21,
+        .variables = lr->osd.vars
+    });
+
+    struct pl_color_repr repr = lr->frame.color_repr;
+    pl_shader_color_map_ex(lr->osd.sh, NULL, pl_color_map_args(
+        .src = pl_color_space_srgb,
+        .dst = lr->frame.color_space
+    ));
+    pl_shader_encode_color(lr->osd.sh, &repr);
+
+    struct pl_dispatch_vertex_params params = { 0 };
+    params = *pl_dispatch_vertex_params(
+        .shader = &lr->osd.sh,
+        .target = lr->frame.fbo,
+        .blend_params = &pl_alpha_overlay,
+        .vertex_attribs = lr->osd.attribs,
+        .num_vertex_attribs = 2,
+        .vertex_stride = sizeof(f32) * 4,
+        .vertex_position_idx = 0,
+        .vertex_coords = PL_COORDS_NORMALIZED,
+        .vertex_flipped = lr->frame.flipped,
+        .vertex_type = PL_PRIM_TRIANGLE_LIST,
+        .vertex_count = 6,
+        .vertex_data = lr->osd.vertices
+    );
+
+    return pl_dispatch_vertex(lr->dispatch, &params);
+}
+
 static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_screen *scr, bool force)
 {
     struct camu_renderer_lp *lr = (struct camu_renderer_lp *)renderer;
@@ -396,9 +606,8 @@ static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
 #endif
 
     if (!lr->have_frame) {
-        struct pl_swapchain_frame frame;
-        if (pl_swapchain_start_frame(lr->swapchain, &frame)) {
-            pl_frame_from_swapchain(&lr->target, &frame);
+        if (pl_swapchain_start_frame(lr->swapchain, &lr->frame)) {
+            pl_frame_from_swapchain(&lr->target, &lr->frame);
             lr->have_frame = true;
 #ifdef CRT_BACKGROUND
             lr->frame_cleared = false;
@@ -413,7 +622,15 @@ static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
     }
 
     f64 mouse_x, mouse_y;
-    bool vr_emulation = scr->vr_emulation && lr->vr_emulation_hook[0];
+    bool vr_emulation = scr->vr_emulation && !lr->vr_init_failed;
+    if (vr_emulation && !lr->vr_emulation_hook[0]) {
+        lr->vr_emulation_hook[0] = pl_mpv_user_shader_parse(lr->gpu, vr_video_shader, sizeof(vr_video_shader) - 1);
+        lr->vr_init_failed = !lr->vr_emulation_hook[0];
+        if (lr->vr_init_failed) {
+            log_error("Failed to compile VR emulation shader.");
+            vr_emulation = false;
+        }
+    }
     if (vr_emulation) {
         mouse_x = (scr->last_pointer_x / scr->width) - (scr->vr_calibrate_x - 0.5);
         mouse_y = (scr->last_pointer_y / scr->height) - (scr->vr_calibrate_y - 0.5);
@@ -484,8 +701,8 @@ static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
                     target->crop.x1 += video->view.x_offset;
                     target->crop.y1 += video->view.y_offset;
                     target->rotation = mix.frames[0]->rotation - video->view.rotation;
-                    /*
                     //lr->params.color_map_params = pl_color_map_params(.inverse_tone_mapping = true);
+                    /*
                     if () {
                         target->color = pl_color_space_srgb;
                         target->color.hdr.max_luma = PL_COLOR_SDR_WHITE - 50.f;
@@ -494,15 +711,7 @@ static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
                     */
 #ifdef CRT_BACKGROUND
                     if (!lr->frame_cleared) {
-                        if (lr->params.background != PL_CLEAR_SKIP) {
-                            clear_color[0] = CRT_BACKGROUND_COLOR_ON;
-                            clear_color[1] = CRT_BACKGROUND_COLOR_ON;
-                            clear_color[2] = CRT_BACKGROUND_COLOR_ON;
-                        } else {
-                            clear_color[0] = 0.f;
-                            clear_color[1] = 0.f;
-                            clear_color[2] = 0.f;
-                        }
+                        CRT_BACKGROUND_COLOR_ON(lr, clear_color);
                         pl_frame_clear_rgba(lr->gpu, &lr->target, clear_color);
                         lr->frame_cleared = true;
                     }
@@ -539,14 +748,20 @@ static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
 
 #ifdef CRT_BACKGROUND
     if (!lr->frame_cleared) {
-        clear_color[0] = CRT_BACKGROUND_COLOR;
-        clear_color[1] = CRT_BACKGROUND_COLOR;
-        clear_color[2] = CRT_BACKGROUND_COLOR;
+        CRT_BACKGROUND_COLOR(clear_color);
         pl_frame_clear_rgba(lr->gpu, &lr->target, clear_color);
         lr->frame_cleared = true;
     }
 #endif
 
+    if (scr->osd.show || (result & RESULT_WAIT)) {
+        al_assert(lr->osd.prelude && lr->osd.header && lr->osd.binds);
+        if (!render_osd(lr, scr) && !lr->osd.logged_fail) {
+            log_error("Failed to render OSD.");
+            lr->osd.logged_fail = true;
+        }
+    }
+
     if (pl_swapchain_submit_frame(lr->swapchain)) {
         lr->have_frame = false;
     } else {
@@ -571,10 +786,25 @@ static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
 void renderer_lp_free(struct camu_renderer **renderer)
 {
     struct camu_renderer_lp *lr = (struct camu_renderer_lp *)*renderer;
+    if (lr->have_frame) {
+        pl_swapchain_submit_frame(lr->swapchain);
+        lr->have_frame = false;
+    }
 #ifdef CAMU_HAVE_SUBTITLES
     if (lr->ass) ass_library_done(lr->ass);
 #endif
     if (lr->vr_emulation_hook[0]) pl_mpv_user_shader_destroy(&lr->vr_emulation_hook[0]);
+#ifdef USE_LIBPLACEBO_CACHE
+    if (lr->cache) {
+        FILE *cache_file = fopen("sink.cache", "wb");
+        if (cache_file) {
+            pl_cache_save_file(lr->cache, cache_file);
+            fclose(cache_file);
+        }
+        pl_cache_destroy(&lr->cache);
+    }
+#endif
+    if (lr->dispatch) pl_dispatch_destroy(&lr->dispatch);
     if (lr->renderer) pl_renderer_destroy(&lr->renderer);
     if (lr->swapchain) pl_swapchain_destroy(&lr->swapchain);
 #if defined STELA_API_VULKAN
diff --git a/src/render/renderer_libplacebo.h b/src/render/renderer_libplacebo.h
index 532963f..a8a5001 100644
--- a/src/render/renderer_libplacebo.h
+++ b/src/render/renderer_libplacebo.h
@@ -16,6 +16,8 @@
 #include <ass/ass.h>
 #endif
 
+//#define USE_LIBPLACEBO_CACHE
+
 struct camu_renderer_lp {
     struct camu_renderer r;
 #if defined STELA_API_VULKAN
@@ -29,15 +31,34 @@ struct camu_renderer_lp {
     pl_opengl gl;
 #endif
     pl_gpu gpu;
+#ifdef USE_LIBPLACEBO_CACHE
+    pl_cache cache;
+#endif
+    pl_dispatch dispatch;
     pl_log logger;
     pl_swapchain swapchain;
-    struct pl_frame target;
+    struct pl_swapchain_frame frame;
     bool have_frame;
     bool frame_cleared;
+    struct pl_frame target;
     pl_renderer renderer;
     f64 last_swap_tick;
     struct pl_render_params params;
+    struct {
+        char *prelude;
+        char *header;
+        char *binds;
+        pl_shader sh;
+        u32 screen_size[2];
+        f32 time;
+        struct pl_shader_var vars[21];
+        f32 vertices[24];
+        struct pl_vertex_attrib attribs[2];
+        f64 tick_time;
+        bool logged_fail;
+    } osd;
     const struct pl_hook *vr_emulation_hook[1];
+    bool vr_init_failed;
 #ifdef CAMU_HAVE_SUBTITLES
     ASS_Library *ass;
 #endif
diff --git a/src/render/shaders/osd.h b/src/render/shaders/osd.h
new file mode 100644
index 0000000..1109a50
--- /dev/null
+++ b/src/render/shaders/osd.h
@@ -0,0 +1,73 @@
+static char osd_shader[] = \
+"float text(vec2 uv, vec2 pos1, vec2 pos2) {\n"
+" float col = 0.;\n"
+" pp = pos1;\n"
+" if (connecting != 0u) {\n"
+"  float t = mod(time,1.8);\n"
+"  for (int i = 0; i < 3; i++) {\n"
+"    col += char(ch_per,uv)*float(t >= float(i)*0.6);\n"
+"  }\n"
+" } else if (paused != 0u) {\n"
+"  col = char(ch_p,uv)+char(ch_a,uv)+char(ch_u,uv)+char(ch_s,uv)+char(ch_e,uv)+char(ch_d,uv);\n"
+" }\n"
+" pp = pos2;\n"
+" if (negative != 0u) {\n"
+"  col += char(ch_dsh,uv);\n"
+" }\n"
+" if (show_hour != 0u) {\n"
+"  col += integer(num1,uv)+char(ch_col,uv);\n"
+" }\n"
+" col += integer(num2,uv)+char(ch_col,uv)+integer(num3,uv)+char(ch_lsl,uv);\n"
+" if (show_hour != 0u) {\n"
+"  col += integer(num4,uv)+char(ch_col,uv);\n"
+" }\n"
+" col += integer(num5,uv)+char(ch_col,uv)+integer(num6,uv);\n"
+" return col;\n"
+"}\n"
+"float text_over(vec2 uv, vec2 pos3) {\n"
+" float col = 0.;\n"
+" pp = pos3;\n"
+" if (show_hour != 0u && bar_mode == 1u) {\n"
+"  col = integer(num7,uv)+char(ch_col,uv);\n"
+" }\n"
+" col += integer(num8,uv)+((bar_mode == 2u) ? char(ch_per,uv) : char(ch_col,uv))+integer(num9,uv);\n"
+" return col;\n"
+"}\n"
+"vec4 draw_osd() {\n"
+" vec2 sf = vec2(screen/scale);\n"
+" vec2 ss = sf/3.;\n"
+" vec2 c = vec2(coord.x,1.-coord.y);\n"
+" vec2 uv = c*ss;\n"
+" vec2 pos1 = vec2(8.,ss.y-4.-STRH(1.));\n"
+" float width1 = (show_hour != 0u) ? 17. : 11.;\n"
+" width1 += float(negative);\n"
+" vec2 pos2 = floor(vec2(ss.x/2.-STRW(width1)/2.,ss.y/9.));\n"
+" pos2.x -= STRW(0.5) * float(negative);\n"
+" float ov = fract(bar);\n"
+" ov = (-1.+(bar-ov)+float(c.x < ov))/1.5;\n"
+" vec4 color = mix(bcolor,mix(tcolor,vec4(0.7,0.45,0.,1.),ov),float(c.x < bar));\n"
+" float alpha = (c.x >= bar) ? 0.7 : 1.;\n"
+" color = mix(color,vec4(tcolor.xyz,alpha)+float(bar > dbar)*0.15,float(c.x < dbar));\n"
+" color = mix(color,vec4(tcolor.xyz,alpha-0.1)+float(bar > bbar)*0.15,float(c.x < bbar)*0.5);\n"
+" color *= float(uv.y <= 5.);\n"
+" if (paused != 0u) {\n"
+"  color = mix(color,bcolor,in_box(uv,pos1-vec2(2.,2.),pos1+vec2(STRW(6.)+1.,STRH(1.)+1.)));\n"
+" }\n"
+" color = mix(color,bcolor,in_box(uv,pos2-vec2(3.,1.),pos2+vec2(STRW(width1)+2.,STRH(1.)+2.)));\n"
+" float pixel = text(uv,pos1,pos2);\n"
+" color = mix(color,tcolor,pixel);\n"
+" color -= pixel*float(mod(c.y*sf.y,3.) < 1.)*0.5;\n"
+" if (bar_mode != 0u) {\n"
+"  ss = sf/2.;\n"
+"  uv = c*ss;\n"
+"  float width2 = (show_hour != 0u && bar_mode == 1u) ? 8. : 5.;\n"
+"  vec2 pos3 = floor(vec2(ss.x/2.-STRW(width2)/2.,11.));\n"
+"  float box = in_box(uv,pos3-vec2(2.,2.),pos3+vec2(STRW(width2)+1.,STRH(1.)+3.));\n"
+"  color.xyz = mix(color.xyz,bcolor.xyz,box);\n"
+"  color.w = color.w+(bcolor.w*box);\n"
+"  pixel = text_over(uv,pos3);\n"
+"  color = mix(color,tcolor,pixel);\n"
+"  color -= pixel*float(mod(c.y*sf.y,2.) < 1.)*0.5;\n"
+" }\n"
+" return color;\n"
+"}\n";
diff --git a/src/render/shaders/osd_binds.h b/src/render/shaders/osd_binds.h
new file mode 100644
index 0000000..5d6806a
--- /dev/null
+++ b/src/render/shaders/osd_binds.h
@@ -0,0 +1,311 @@
+static char osd_binds_shader[] = \
+"float text(vec2 uv, vec2 pos) {\n"
+" float col = 0.;\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_L,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_f,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_lsl,uv);\n"
+" col += char(ch_R,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_g,uv);\n"
+" col += char(ch_h,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(1)\n"
+" col += char(ch_N,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_x,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_lsl,uv);\n"
+" col += char(ch_P,uv);\n"
+" col += char(ch_r,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_v,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_o,uv);\n"
+" col += char(ch_u,uv);\n"
+" col += char(ch_s,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_lpa,uv);\n"
+" col += char(ch_C,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_r,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_col,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_crs,uv);\n"
+" col += char(ch_lsl,uv);\n"
+" col += char(ch_dsh,uv);\n"
+" col += char(ch_1,uv);\n"
+" col += char(ch_0,uv);\n"
+" col += char(ch_s,uv);\n"
+" col += char(ch_rpa,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_p,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_c,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(6)\n"
+" col += char(ch_P,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_u,uv);\n"
+" col += char(ch_s,uv);\n"
+" col += char(ch_e,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_M,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_M,uv);\n"
+" col += char(ch_u,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_lpa,uv);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_h,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_f,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_col,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_1,uv);\n"
+" col += char(ch_0,uv);\n"
+" col += char(ch_0,uv);\n"
+" col += char(ch_pct,uv);\n"
+" col += char(ch_rpa,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_T,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_b,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(8)\n"
+" col += char(ch_T,uv);\n"
+" col += char(ch_o,uv);\n"
+" col += char(ch_g,uv);\n"
+" col += char(ch_g,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_O,uv);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_D,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_C,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_r,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(7)\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_h,uv);\n"
+" col += char(ch_o,uv);\n"
+" col += char(ch_w,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_O,uv);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_D,uv);\n"
+" col += char(ch_lsl,uv);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_k,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_lpa,uv);\n"
+" col += char(ch_C,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_c,uv);\n"
+" col += char(ch_k,uv);\n"
+" col += char(ch_rpa,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_T,uv);\n"
+" col += char(ch_o,uv);\n"
+" col += char(ch_g,uv);\n"
+" col += char(ch_g,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_u,uv);\n"
+" col += char(ch_b,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_s,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_E,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_R,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_s,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_k,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_crs,uv);\n"
+" col += char(ch_lsl,uv);\n"
+" col += char(ch_dsh,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(8)\n"
+" col += char(ch_Z,uv);\n"
+" col += char(ch_o,uv);\n"
+" col += char(ch_o,uv);\n"
+" col += char(ch_m,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_I,uv);\n"
+" col += char(ch_n,uv);\n"
+" col += char(ch_lsl,uv);\n"
+" col += char(ch_O,uv);\n"
+" col += char(ch_u,uv);\n"
+" col += char(ch_t,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_N,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_D,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_s,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_b,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_c,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_n,uv);\n"
+" col += char(ch_g,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_C,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_T,uv);\n"
+" col += char(ch_r,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_n,uv);\n"
+" col += char(ch_s,uv);\n"
+" col += char(ch_p,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_r,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_n,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_B,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_c,uv);\n"
+" col += char(ch_k,uv);\n"
+" col += char(ch_g,uv);\n"
+" col += char(ch_r,uv);\n"
+" col += char(ch_o,uv);\n"
+" col += char(ch_u,uv);\n"
+" col += char(ch_n,uv);\n"
+" col += char(ch_d,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_V,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_V,uv);\n"
+" col += char(ch_R,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_lpa,uv);\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_h,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_f,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_col,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_3,uv);\n"
+" col += char(ch_6,uv);\n"
+" col += char(ch_0,uv);\n"
+" col += char(ch_dgr,uv);\n"
+" col += char(ch_com,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_C,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_r,uv);\n"
+" col += char(ch_l,uv);\n"
+" col += char(ch_col,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_C,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_n,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_r,uv);\n"
+" col += char(ch_rpa,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_B,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_S,uv);\n"
+" col += char(ch_w,uv);\n"
+" col += char(ch_a,uv);\n"
+" col += char(ch_p,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_E,uv);\n"
+" col += char(ch_y,uv);\n"
+" col += char(ch_e,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_R,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_R,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_s,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_t,uv);\n"
+" col += char(ch_spc,uv);\n"
+" col += char(ch_V,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_e,uv);\n"
+" col += char(ch_w,uv);\n"
+" pos.y -= STRH(1.2);\n"
+" pp = vec2(pos.x,pos.y);\n"
+" col += char(ch_Q,uv);\n"
+" col += char(ch_col,uv);\n"
+" spaces(10)\n"
+" col += char(ch_Q,uv);\n"
+" col += char(ch_u,uv);\n"
+" col += char(ch_i,uv);\n"
+" col += char(ch_t,uv);\n"
+" return col;\n"
+"}\n"
+"vec4 draw_osd() {\n"
+" vec2 sf = vec2(screen/scale);\n"
+" vec2 ss = sf/2.;\n"
+" vec2 c = vec2(coord.x,1.-coord.y);\n"
+" vec2 uv = c*ss;\n"
+" vec2 pos = floor(vec2(ss.x/2.-STRW(43.)/2.,(ss.y/2.)+STRH(1.2*10.)));\n"
+" float pixel = text(uv, pos);\n"
+" float box = in_box(uv,pos-vec2(8.,STRH(1.2*13.)+8.),pos+vec2(STRW(43.)+8.,STRH(1.2)+8.));\n"
+" vec4 color = bcolor*box;\n"
+" color = mix(color,tcolor,pixel);\n"
+" color -= pixel*float(mod(c.y*sf.y,3.) < 1.)*0.5;\n"
+" return color;\n"
+"}\n";
diff --git a/src/render/shaders/osd_header.h b/src/render/shaders/osd_header.h
new file mode 100644
index 0000000..5ba6491
--- /dev/null
+++ b/src/render/shaders/osd_header.h
@@ -0,0 +1,146 @@
+static char osd_header_shader[] = \
+"#define ch_dgr uvec4(0x001824,0x241800,0x000000,0x000000)\n"
+"#define ch_spc uvec4(0x000000,0x000000,0x000000,0x000000)\n"
+"#define ch_exc uvec4(0x003078,0x787830,0x300030,0x300000)\n"
+"#define ch_quo uvec4(0x006666,0x662400,0x000000,0x000000)\n"
+"#define ch_hsh uvec4(0x006C6C,0xFE6C6C,0x6CFE6C,0x6C0000)\n"
+"#define ch_dol uvec4(0x30307C,0xC0C078,0x0C0CF8,0x303000)\n"
+"#define ch_pct uvec4(0x000000,0xC4CC18,0x3060CC,0x8C0000)\n"
+"#define ch_amp uvec4(0x0070D8,0xD870FA,0xDECCDC,0x760000)\n"
+"#define ch_apo uvec4(0x003030,0x306000,0x000000,0x000000)\n"
+"#define ch_lbr uvec4(0x000C18,0x306060,0x603018,0x0C0000)\n"
+"#define ch_rbr uvec4(0x006030,0x180C0C,0x0C1830,0x600000)\n"
+"#define ch_ast uvec4(0x000000,0x663CFF,0x3C6600,0x000000)\n"
+"#define ch_crs uvec4(0x000000,0x18187E,0x181800,0x000000)\n"
+"#define ch_com uvec4(0x000000,0x000000,0x000038,0x386000)\n"
+"#define ch_dsh uvec4(0x000000,0x0000FE,0x000000,0x000000)\n"
+"#define ch_per uvec4(0x000000,0x000000,0x000038,0x380000)\n"
+"#define ch_lsl uvec4(0x000002,0x060C18,0x3060C0,0x800000)\n"
+"#define ch_0 uvec4(0x007CC6,0xD6D6D6,0xD6D6C6,0x7C0000)\n"
+"#define ch_1 uvec4(0x001030,0xF03030,0x303030,0xFC0000)\n"
+"#define ch_2 uvec4(0x0078CC,0xCC0C18,0x3060CC,0xFC0000)\n"
+"#define ch_3 uvec4(0x0078CC,0x0C0C38,0x0C0CCC,0x780000)\n"
+"#define ch_4 uvec4(0x000C1C,0x3C6CCC,0xFE0C0C,0x1E0000)\n"
+"#define ch_5 uvec4(0x00FCC0,0xC0C0F8,0x0C0CCC,0x780000)\n"
+"#define ch_6 uvec4(0x003860,0xC0C0F8,0xCCCCCC,0x780000)\n"
+"#define ch_7 uvec4(0x00FEC6,0xC6060C,0x183030,0x300000)\n"
+"#define ch_8 uvec4(0x0078CC,0xCCEC78,0xDCCCCC,0x780000)\n"
+"#define ch_9 uvec4(0x0078CC,0xCCCC7C,0x181830,0x700000)\n"
+"#define ch_col uvec4(0x000000,0x383800,0x003838,0x000000)\n"
+"#define ch_scl uvec4(0x000000,0x383800,0x003838,0x183000)\n"
+"#define ch_les uvec4(0x000C18,0x3060C0,0x603018,0x0C0000)\n"
+"#define ch_equ uvec4(0x000000,0x007E00,0x7E0000,0x000000)\n"
+"#define ch_grt uvec4(0x006030,0x180C06,0x0C1830,0x600000)\n"
+"#define ch_que uvec4(0x0078CC,0x0C1830,0x300030,0x300000)\n"
+"#define ch_ats uvec4(0x007CC6,0xC6DEDE,0xDEC0C0,0x7C0000)\n"
+"#define ch_A uvec4(0x003078,0xCCCCCC,0xFCCCCC,0xCC0000)\n"
+"#define ch_B uvec4(0x00FC66,0x66667C,0x666666,0xFC0000)\n"
+"#define ch_C uvec4(0x003C66,0xC6C0C0,0xC0C666,0x3C0000)\n"
+"#define ch_D uvec4(0x00F86C,0x666666,0x66666C,0xF80000)\n"
+"#define ch_E uvec4(0x00FE62,0x60647C,0x646062,0xFE0000)\n"
+"#define ch_F uvec4(0x00FE66,0x62647C,0x646060,0xF00000)\n"
+"#define ch_G uvec4(0x003C66,0xC6C0C0,0xCEC666,0x3E0000)\n"
+"#define ch_H uvec4(0x00CCCC,0xCCCCFC,0xCCCCCC,0xCC0000)\n"
+"#define ch_I uvec4(0x007830,0x303030,0x303030,0x780000)\n"
+"#define ch_J uvec4(0x001E0C,0x0C0C0C,0xCCCCCC,0x780000)\n"
+"#define ch_K uvec4(0x00E666,0x6C6C78,0x6C6C66,0xE60000)\n"
+"#define ch_L uvec4(0x00F060,0x606060,0x626666,0xFE0000)\n"
+"#define ch_M uvec4(0x00C6EE,0xFEFED6,0xC6C6C6,0xC60000)\n"
+"#define ch_N uvec4(0x00C6C6,0xE6F6FE,0xDECEC6,0xC60000)\n"
+"#define ch_O uvec4(0x00386C,0xC6C6C6,0xC6C66C,0x380000)\n"
+"#define ch_P uvec4(0x00FC66,0x66667C,0x606060,0xF00000)\n"
+"#define ch_Q uvec4(0x00386C,0xC6C6C6,0xCEDE7C,0x0C1E00)\n"
+"#define ch_R uvec4(0x00FC66,0x66667C,0x6C6666,0xE60000)\n"
+"#define ch_S uvec4(0x0078CC,0xCCC070,0x18CCCC,0x780000)\n"
+"#define ch_T uvec4(0x00FCB4,0x303030,0x303030,0x780000)\n"
+"#define ch_U uvec4(0x00CCCC,0xCCCCCC,0xCCCCCC,0x780000)\n"
+"#define ch_V uvec4(0x00CCCC,0xCCCCCC,0xCCCC78,0x300000)\n"
+"#define ch_W uvec4(0x00C6C6,0xC6C6D6,0xD66C6C,0x6C0000)\n"
+"#define ch_X uvec4(0x00CCCC,0xCC7830,0x78CCCC,0xCC0000)\n"
+"#define ch_Y uvec4(0x00CCCC,0xCCCC78,0x303030,0x780000)\n"
+"#define ch_Z uvec4(0x00FECE,0x981830,0x6062C6,0xFE0000)\n"
+"#define ch_lsb uvec4(0x003C30,0x303030,0x303030,0x3C0000)\n"
+"#define ch_rsl uvec4(0x000080,0xC06030,0x180C06,0x020000)\n"
+"#define ch_rsb uvec4(0x003C0C,0x0C0C0C,0x0C0C0C,0x3C0000)\n"
+"#define ch_pow uvec4(0x10386C,0xC60000,0x000000,0x000000)\n"
+"#define ch_usc uvec4(0x000000,0x000000,0x000000,0x00FF00)\n"
+"#define ch_a uvec4(0x000000,0x00780C,0x7CCCCC,0x760000)\n"
+"#define ch_b uvec4(0x00E060,0x607C66,0x666666,0xDC0000)\n"
+"#define ch_c uvec4(0x000000,0x0078CC,0xC0C0CC,0x780000)\n"
+"#define ch_d uvec4(0x001C0C,0x0C7CCC,0xCCCCCC,0x760000)\n"
+"#define ch_e uvec4(0x000000,0x0078CC,0xFCC0CC,0x780000)\n"
+"#define ch_f uvec4(0x00386C,0x6060F8,0x606060,0xF00000)\n"
+"#define ch_g uvec4(0x000000,0x0076CC,0xCCCC7C,0x0CCC78)\n"
+"#define ch_h uvec4(0x00E060,0x606C76,0x666666,0xE60000)\n"
+"#define ch_i uvec4(0x001818,0x007818,0x181818,0x7E0000)\n"
+"#define ch_j uvec4(0x000C0C,0x003C0C,0x0C0C0C,0xCCCC78)\n"
+"#define ch_k uvec4(0x00E060,0x60666C,0x786C66,0xE60000)\n"
+"#define ch_l uvec4(0x007818,0x181818,0x181818,0x7E0000)\n"
+"#define ch_m uvec4(0x000000,0x00FCD6,0xD6D6D6,0xC60000)\n"
+"#define ch_n uvec4(0x000000,0x00F8CC,0xCCCCCC,0xCC0000)\n"
+"#define ch_o uvec4(0x000000,0x0078CC,0xCCCCCC,0x780000)\n"
+"#define ch_p uvec4(0x000000,0x00DC66,0x666666,0x7C60F0)\n"
+"#define ch_q uvec4(0x000000,0x0076CC,0xCCCCCC,0x7C0C1E)\n"
+"#define ch_r uvec4(0x000000,0x00EC6E,0x766060,0xF00000)\n"
+"#define ch_s uvec4(0x000000,0x0078CC,0x6018CC,0x780000)\n"
+"#define ch_t uvec4(0x000020,0x60FC60,0x60606C,0x380000)\n"
+"#define ch_u uvec4(0x000000,0x00CCCC,0xCCCCCC,0x760000)\n"
+"#define ch_v uvec4(0x000000,0x00CCCC,0xCCCC78,0x300000)\n"
+"#define ch_w uvec4(0x000000,0x00C6C6,0xD6D66C,0x6C0000)\n"
+"#define ch_x uvec4(0x000000,0x00C66C,0x38386C,0xC60000)\n"
+"#define ch_y uvec4(0x000000,0x006666,0x66663C,0x0C18F0)\n"
+"#define ch_z uvec4(0x000000,0x00FC8C,0x1860C4,0xFC0000)\n"
+"#define ch_lpa uvec4(0x001C30,0x3060C0,0x603030,0x1C0000)\n"
+"#define ch_bar uvec4(0x001818,0x181800,0x181818,0x180000)\n"
+"#define ch_rpa uvec4(0x00E030,0x30180C,0x183030,0xE00000)\n"
+"#define ch_tid uvec4(0x0073DA,0xCE0000,0x000000,0x000000)\n"
+"#define ch_lar uvec4(0x000000,0x10386C,0xC6C6FE,0x000000)\n"
+"#define spaces(n) for (int i = 0; i < n; i++) { col += char(ch_spc,uv); }\n"
+"#define STRW(c) (c*8.)\n"
+"#define STRH(c) (c*12.)\n"
+"const vec4 tcolor = vec4(0.78,0.76,0.76,1.);\n"
+"const vec4 bcolor = vec4(0.1,0.1,0.1,0.65);\n"
+"vec2 pp = vec2(0.);\n"
+"float in_box(vec2 v, vec2 bl, vec2 tr) {\n"
+" vec2 s = step(bl,v)-step(tr,v);\n"
+" return s.x*s.y;\n"
+"}\n"
+"float sprite(uvec4 spr, vec2 uv) {\n"
+" uint b = uint((7.-uv.x)+uv.y*8.);\n"
+" uvec4 bv = (spr>>min(uvec4(b-72u,b-48u,b-24u,b),31u))&1u;\n"
+#ifndef NAUNET_ON_ANDROID
+#define HAVE_UVEC_DOT
+#endif
+#ifdef HAVE_UVEC_DOT
+" return in_box(uv,vec2(0.),vec2(8.,12.))*float(dot(bv,uvec4(1u)));\n"
+#else
+" return in_box(uv,vec2(0.),vec2(8.,12.))*float(bv.x+bv.y+bv.z+bv.w);\n"
+#endif
+"}\n"
+"float char(uvec4 ch, vec2 uv) {\n"
+" float px = sprite(ch,floor(uv-pp));\n"
+" pp += vec2(8.,0.);\n"
+" return px;\n"
+"}\n"
+"uvec4 digit(uint d) {\n"
+" switch (d) {\n"
+"  case 0: return ch_0;\n"
+"  case 1: return ch_1;\n"
+"  case 2: return ch_2;\n"
+"  case 3: return ch_3;\n"
+"  case 4: return ch_4;\n"
+"  case 5: return ch_5;\n"
+"  case 6: return ch_6;\n"
+"  case 7: return ch_7;\n"
+"  case 8: return ch_8;\n"
+"  case 9:\n"
+"  default: return ch_9;\n"
+" }\n"
+"}\n"
+"float integer(uint number, vec2 uv) {\n"
+" float r = 0.;\n"
+" for (int i = 1; i >= 0; i--) {\n"
+"  r += char(digit(uint(mod(float(number)/max(1.,float(i)*10.),10.))),uv);\n"
+" }\n"
+" return r;\n"
+"}\n";
diff --git a/src/screen/screen.c b/src/screen/screen.c
index c0527c3..ae9b001 100644
--- a/src/screen/screen.c
+++ b/src/screen/screen.c
@@ -24,6 +24,8 @@
 #define SCREEN_LAST_CLICK_WITHIN(ns) \
     (((scr)->last_click_ts != SCREEN_INVALID_TS) && (nn_get_timestamp() - (scr)->last_click_ts <= ns))
 
+#define SCREEN_OSD_BAR_HEIGHT 15
+
 static void should_close_callback(void *userdata)
 {
     struct camu_screen *scr = (struct camu_screen *)userdata;
@@ -62,15 +64,15 @@ static void resize_callback(void *userdata, u32 width, u32 height)
     do_resize(scr, width, height);
 }
 
+// @TODO: Incomplete.
 static struct camu_view *get_view_from_mouse_pos(struct camu_screen *scr)
 {
     struct camu_view *view = NULL;
+    if (scr->videos.count > 0) {
+        view = &al_array_last(scr->videos).view;
+    }
     struct camu_screen_video *video;
     al_array_foreach_ptr(scr->videos, i, video) {
-        if (!view) {
-            view = &video->view;
-            continue;
-        }
         if (view->zindex < video->view.zindex) {
             view = &video->view;
         }
@@ -85,21 +87,26 @@ static void seek_to_percent_at_pointer(struct camu_screen *scr, f64 x)
     scr->callback(scr->userdata, CAMU_SCREEN_PERCENT_SEEK, &percent);
 }
 
-static bool pointer_pos_callback(void *userdata, f64 x, f64 y)
+static bool pointer_callback(void *userdata, u8 type, f64 x, f64 y)
 {
     struct camu_screen *scr = (struct camu_screen *)userdata;
     struct camu_view *view = get_view_from_mouse_pos(scr);
     bool queue_refresh = false;
-    if (SCREEN_IS_DRAGGING(scr)) {
-#ifdef CAMU_SCREEN_DRAG_SEEK
-        u64 now = nn_get_timestamp();
-        if (view && now - scr->last_seek_ts > 100000) {
-            seek_to_percent_at_pointer(scr, x);
-            scr->last_seek_ts = now;
+    bool have_pointer_move = scr->window->flags & STELA_WINDOW_SUPPORTS_POINTER_MOVE;
+    switch (type) {
+    case STELA_POINTER_POS:
+        if (scr->vr_emulation && have_pointer_move) {
+            break;
         }
+        if (SCREEN_IS_DRAGGING(scr)) {
+#ifdef CAMU_SCREEN_DRAG_SEEK
+            u64 now = nn_get_timestamp();
+            if (view && now - scr->last_seek_ts > 100000) {
+                seek_to_percent_at_pointer(scr, x);
+                scr->last_seek_ts = now;
+            }
 #else
-        if (view) {
-            if (SCREEN_ZOOM_MODE(scr, CAMU_SCREEN_ZOOM_PAN_SIMPLE)) {
+            if (view && !SCREEN_MOD1(scr) && SCREEN_ZOOM_MODE(scr, CAMU_SCREEN_ZOOM_PAN_SIMPLE)) {
                 f64 dx = x - scr->last_pointer_x;
                 f64 dy = y - scr->last_pointer_y;
                 if (camu_view_pan_simple(view, scr->width, scr->height, dx, dy)) {
@@ -110,11 +117,26 @@ static bool pointer_pos_callback(void *userdata, f64 x, f64 y)
                     scr->last_click_ts = SCREEN_INVALID_TS;
                 }
             }
-        }
 #endif
+        }
+        if (SCREEN_MOD1(scr) && scr->osd.duration > 0) {
+            f64 dx = x - scr->last_pointer_x;
+            if (fabs(dx) >= 2.0 || y >= scr->height - SCREEN_OSD_BAR_HEIGHT) {
+                scr->osd.bar_mode = CAMU_OSD_BAR_SEEK;
+            }
+        }
+        scr->last_pointer_x = x;
+        scr->last_pointer_y = y;
+        break;
+    case STELA_POINTER_MOVE:
+        if (!scr->vr_emulation || !have_pointer_move) {
+            break;
+        }
+        scr->last_pointer_x += x * 0.75f;
+        scr->last_pointer_y += y * 0.75f;
+        queue_refresh = true;
+        break;
     }
-    scr->last_pointer_x = x;
-    scr->last_pointer_y = y;
     return queue_refresh;
 }
 
@@ -169,7 +191,7 @@ static bool touch_callback(void *userdata, s32 index, u8 phase, f64 x, f64 y)
             f64 lx = scr->last_touch_x[0], lx2 = scr->last_touch_x[1];
             f64 ly = scr->last_touch_y[0], ly2 = scr->last_touch_y[1];
             f64 dist = distance(lx, lx2, ly, ly2);
-            f64 mx = x = (lx + lx2) / 2.0, my = (ly + ly2) / 2.0;
+            f64 mx = (lx + lx2) / 2.0, my = (ly + ly2) / 2.0;
             bool refresh = false;
             struct camu_view *view = get_view_from_mouse_pos(scr);
             if (view) {
@@ -190,7 +212,7 @@ static bool touch_callback(void *userdata, s32 index, u8 phase, f64 x, f64 y)
                 scr->last_pointer_x = scr->last_touch_x[1];
                 scr->last_pointer_y = scr->last_touch_y[1];
             }
-            bool refresh = pointer_pos_callback(scr, x, y);
+            bool refresh = pointer_callback(scr, STELA_POINTER_POS, x, y);
             if (index == 0) {
                 scr->last_touch_x[0] = x;
                 scr->last_touch_y[0] = y;
@@ -213,7 +235,12 @@ static bool touch_callback(void *userdata, s32 index, u8 phase, f64 x, f64 y)
             if (SCREEN_LAST_CLICK_WITHIN(200000)) {
                 f64 third = scr->width / 3.0;
                 if (x >= third && x <= third * 2.0) {
-                    scr->callback(scr->userdata, CAMU_SCREEN_TOGGLE_PAUSE, NULL);
+                    if (scr->vr_emulation) {
+                        scr->vr_calibrate_x = scr->last_pointer_x / scr->width;
+                        scr->vr_calibrate_y = scr->last_pointer_y / scr->height;
+                    } else {
+                        scr->callback(scr->userdata, CAMU_SCREEN_TOGGLE_PAUSE, NULL);
+                    }
                 } else {
                     if (scr->touch_mode) {
 #if CAMU_HAVE_SUBTITLES
@@ -246,7 +273,8 @@ static bool mouse_button_callback(void *userdata, u8 state, u8 button)
             break;
         case STELA_BUTTON_RELEASED:
             scr->flags &= ~CAMU_SCREEN_DRAGGING;
-            scr->window->set_cursor(scr->window, SCREEN_MOUSE_MOD(scr) ? STELA_CURSOR_CROSSHAIR : SCREEN_DEFAULT_CURSOR(scr));
+            bool want_crosshair = SCREEN_MOUSE_MOD(scr) && scr->fullscreen;
+            scr->window->set_cursor(scr->window, want_crosshair ? STELA_CURSOR_CROSSHAIR : SCREEN_DEFAULT_CURSOR(scr));
             if (SCREEN_LAST_CLICK_WITHIN(200000)) {
                 if (SCREEN_MOD1(scr)) {
                     seek_to_percent_at_pointer(scr, scr->last_pointer_x);
@@ -295,6 +323,9 @@ bool scroll_callback(void *userdata, f64 y)
     if (SCREEN_MOD1(scr)) {
         f32 change = (f32)stl_scale_scroll(y, 40.0);
         scr->callback(scr->userdata, CAMU_SCREEN_OFFSET_VOLUME, &change);
+        scr->osd.bar_mode = CAMU_OSD_BAR_VOLUME;
+        scr->osd.bar = change;
+        return true;
     } else {
         struct camu_view *view = get_view_from_mouse_pos(scr);
         if (view) {
@@ -321,14 +352,21 @@ static bool key_callback(void *userdata, u8 state, u16 button)
             scr->window->close(scr->window);
             scr->callback(scr->userdata, CAMU_SCREEN_CLOSE, NULL);
             break;
+        case STELA_KEY_SLASH:
+            scr->osd.show_binds = !scr->osd.show_binds;
+            break;
         case STELA_KEY_RIGHT:
             if (SCREEN_MOD1(scr)) {
-                f64 plus_ten_seconds = 10.0;
-                scr->callback(scr->userdata, CAMU_SCREEN_RELATIVE_SEEK, &plus_ten_seconds);
+                if (SCREEN_MOD2(scr)) {
+                    f64 one_hundred = 100.0;
+                    scr->callback(scr->userdata, CAMU_SCREEN_PERCENT_SEEK, &one_hundred);
+                } else {
+                    f64 plus_ten_seconds = 10.0;
+                    scr->callback(scr->userdata, CAMU_SCREEN_RELATIVE_SEEK, &plus_ten_seconds);
+                }
                 break;
             }
             // fallthrough
-        case STELA_KEY_TAB:
         case STELA_KEY_D: {
             s32 n = 1;
             scr->callback(scr->userdata, CAMU_SCREEN_SKIP, &n);
@@ -351,6 +389,31 @@ static bool key_callback(void *userdata, u8 state, u16 button)
             scr->callback(scr->userdata, CAMU_SCREEN_SKIP, &n);
             break;
         }
+        case STELA_KEY_LEFT_CONTROL:
+        case STELA_KEY_RIGHT_CONTROL:
+            if (scr->osd.shown_for & CAMU_OSD_VOLUME) {
+                scr->osd.shown_for &= ~CAMU_OSD_VOLUME;
+                scr->osd.shown_for |= CAMU_OSD_SEEK;
+            } else if (!scr->osd.show) {
+                scr->osd.show = true;
+                scr->osd.shown_for |= CAMU_OSD_SEEK;
+            }
+            if (scr->last_pointer_y >= scr->height - SCREEN_OSD_BAR_HEIGHT) {
+                scr->osd.bar_mode = CAMU_OSD_BAR_SEEK;
+            }
+            break;
+        case STELA_KEY_TAB:
+            if (!(scr->osd.shown_for & CAMU_OSD_SEEK)) {
+                if (scr->osd.flash >= 0.0) {
+                    scr->osd.flash = 0.0;
+                } else {
+                    scr->osd.show = !scr->osd.show;
+                    scr->osd.shown_for = 0;
+                    atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
+                }
+                return true;
+            }
+            break;
         case STELA_KEY_SPACE:
             scr->callback(scr->userdata, CAMU_SCREEN_TOGGLE_PAUSE, NULL);
             break;
@@ -366,22 +429,22 @@ static bool key_callback(void *userdata, u8 state, u16 button)
             }
             break;
         case STELA_KEY_E:
-            if (scr->vr_emulation) {
-                if (scr->vr_emulation == CAMU_VR_180) {
-                    scr->vr_left_eye = !scr->vr_left_eye;
-                    log_info(scr->vr_left_eye ? "Left eye." : "Right eye.");
-                }
-            } else {
-                scr->callback(scr->userdata, CAMU_SCREEN_RESEEK, NULL);
-            }
+            scr->callback(scr->userdata, CAMU_SCREEN_RESEEK, NULL);
             break;
         case STELA_KEY_M: {
-            f32 volume = SCREEN_MOD1(scr) ? 1.f : -1.f;
+            f32 volume = SCREEN_MOD2(scr) ? 1.f : -1.f;
             scr->callback(scr->userdata, CAMU_SCREEN_SET_VOLUME, &volume);
+            scr->osd.bar_mode = CAMU_OSD_BAR_VOLUME;
+            scr->osd.bar = volume;
+            scr->osd.flash = CAMU_OSD_FLASH_FOR(0.75);
+            if (!scr->osd.show) {
+                scr->osd.show = true;
+                scr->osd.shown_for |= CAMU_OSD_VOLUME;
+            }
             break;
         }
         case STELA_KEY_0:
-            scr->callback(scr->userdata, CAMU_SCREEN_STATUS, NULL);
+            scr->callback(scr->userdata, CAMU_SCREEN_PRINT, NULL);
             break;
 #ifdef CAMU_SCREEN_DEBUG_KEY
         case STELA_KEY_P:
@@ -504,9 +567,14 @@ static bool key_callback(void *userdata, u8 state, u16 button)
                     scr->vr_emulation = CAMU_VR_DISABLED;
                     log_info("VR disabled.");
                 }
-                if (view) {
-                    camu_view_calculate(view, scr->width, scr->height);
-                }
+                if (view) camu_view_calculate(view, scr->width, scr->height);
+            }
+            break;
+        }
+        case STELA_KEY_B: {
+            if (scr->vr_emulation == CAMU_VR_180) {
+                scr->vr_left_eye = !scr->vr_left_eye;
+                log_info(scr->vr_left_eye ? "Left eye." : "Right eye.");
             }
             break;
         }
@@ -515,6 +583,17 @@ static bool key_callback(void *userdata, u8 state, u16 button)
         }
         break;
     case STELA_BUTTON_RELEASED:
+        switch (button) {
+        case STELA_KEY_LEFT_CONTROL:
+        case STELA_KEY_RIGHT_CONTROL:
+            if (scr->osd.shown_for & CAMU_OSD_SEEK) {
+                scr->osd.shown_for &= ~CAMU_OSD_SEEK;
+                scr->osd.show = false;
+                atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
+            }
+            scr->osd.bar_mode = CAMU_OSD_BAR_PROGRESS;
+            return true;
+        }
         break;
     default:
         break;
@@ -529,11 +608,10 @@ static bool key_immediate_callback(void *userdata, u8 state, u16 button)
     case STELA_BUTTON_PRESSED:
         switch (button) {
         case STELA_KEY_F:
-            scr->fullscreen = !scr->fullscreen;
             // On X11 and Wayland, MOUSE2 will be forcefully released when entering fullscreen.
-            if (!SCREEN_MOUSE_MOD(scr)) {
-                scr->window->set_cursor(scr->window, scr->fullscreen ? STELA_CURSOR_HIDDEN : STELA_CURSOR_NORMAL);
-            }
+            scr->fullscreen = !scr->fullscreen;
+            bool want_crosshair = SCREEN_MOUSE_MOD(scr) && scr->fullscreen;
+            scr->window->set_cursor(scr->window, want_crosshair ? STELA_CURSOR_CROSSHAIR : SCREEN_DEFAULT_CURSOR(scr));
 //#ifdef STELA_API_DX11
 #if 0 // Stela's window_win32 fullscreen mode (borderless) is likely more desirable here.
             scr->renderer->set(scr->renderer, CAMU_RENDERER_FULLSCREEN, scr->fullscreen);
@@ -563,18 +641,29 @@ static bool key_immediate_callback(void *userdata, u8 state, u16 button)
     return false;
 }
 
+#ifdef STELA_DRAG_AND_DROP
+static void drag_and_drop_callback(void *userdata, str *path)
+{
+    struct camu_screen *scr = (struct camu_screen *)userdata;
+    scr->callback(scr->userdata, CAMU_SCREEN_ADD, path);
+}
+#endif
+
 bool camu_screen_init(struct camu_screen *scr)
 {
     atomic_store(s32)(&scr->state, CAMU_SCREEN_PAUSED, AL_ATOMIC_RELAXED);
     scr->window = stl_window_create();
     scr->window->render_callback = render_callback;
     scr->window->resize_callback = resize_callback;
-    scr->window->pointer_pos_callback = pointer_pos_callback;
+    scr->window->pointer_callback = pointer_callback;
     scr->window->touch_callback = touch_callback;
     scr->window->scroll_callback = scroll_callback;
     scr->window->mouse_button_callback = mouse_button_callback;
     scr->window->key_callback = key_callback;
     scr->window->key_immediate_callback = key_immediate_callback;
+#ifdef STELA_DRAG_AND_DROP
+    scr->window->drag_and_drop_callback = drag_and_drop_callback;
+#endif
     scr->window->should_close_callback = should_close_callback;
     scr->window->userdata = scr;
     scr->renderer = NULL;
@@ -592,6 +681,9 @@ bool camu_screen_init(struct camu_screen *scr)
     scr->last_seek_ts = 0;
 #endif
     scr->touch_mode = false;
+    scr->osd.show_binds = false;
+    scr->osd.bar = -1.0;
+    scr->osd.flash = -1.0;
     scr->vr_emulation = CAMU_VR_DISABLED;
     scr->vr_left_eye = false;
     scr->vr_calibrate_x = 0.5;
@@ -849,7 +941,9 @@ bool camu_screen_tick(struct camu_screen *scr, bool *force)
 {
     s32 state = atomic_load(s32)(&scr->state, AL_ATOMIC_RELAXED);
     u32 force_refresh = atomic_load(u32)(&scr->force_refresh, AL_ATOMIC_ACQUIRE);
-    bool paused = !scr->vr_emulation && state == CAMU_SCREEN_PAUSED && force_refresh == 0;
+    bool paused = state == CAMU_SCREEN_PAUSED && force_refresh == 0;
+    paused &= !scr->osd.show;
+    paused &= !scr->vr_emulation;
     bool do_render = camu_screen_poll(scr, paused) || !paused;
     force_refresh = atomic_load(u32)(&scr->force_refresh, AL_ATOMIC_ACQUIRE);
     do_render |= force_refresh > 0;
@@ -858,6 +952,36 @@ bool camu_screen_tick(struct camu_screen *scr, bool *force)
     if (force_refresh > 0) {
         atomic_sub(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELEASE);
     }
+    bool was_paused = scr->osd.paused;
+    scr->callback(scr->userdata, CAMU_SCREEN_STATUS, &scr->osd);
+    if (!SCREEN_MOD1(scr)) {
+        if (scr->osd.flash >= 0.0) {
+            if (nn_get_tick() >= scr->osd.flash) {
+                scr->osd.flash = -1.0;
+                scr->osd.shown_for = 0;
+                scr->osd.show = false;
+                scr->osd.bar_mode = CAMU_OSD_BAR_PROGRESS;
+                *force = true;
+            } else {
+                scr->osd.show = true;
+            }
+        }
+    }
+    if (scr->osd.bar_mode == CAMU_OSD_BAR_SEEK) {
+        f64 percent = scr->last_pointer_x / scr->width;
+        scr->osd.bar = CLAMP(percent, 0.0, 100.0);
+    }
+    if (was_paused != scr->osd.paused) {
+        if (scr->osd.paused && !scr->osd.show) {
+            scr->osd.show = true;
+            scr->osd.shown_for |= CAMU_OSD_PAUSE;
+        } else if (scr->osd.shown_for & CAMU_OSD_PAUSE) {
+            scr->osd.shown_for &= ~CAMU_OSD_PAUSE;
+            scr->osd.show = false;
+        }
+        *force = true;
+    }
+    *force |= scr->osd.show;
     return do_render;
 }
 
diff --git a/src/screen/screen.h b/src/screen/screen.h
index 0d40a02..c3dcd7d 100644
--- a/src/screen/screen.h
+++ b/src/screen/screen.h
@@ -39,6 +39,7 @@ enum {
 enum {
     CAMU_SCREEN_SET_VOLUME = 0, // f32
     CAMU_SCREEN_OFFSET_VOLUME, // f32
+    CAMU_SCREEN_ADD, // str
     CAMU_SCREEN_SKIP, // s32
     CAMU_SCREEN_TOGGLE_PAUSE,
     CAMU_SCREEN_PERCENT_SEEK, // f64
@@ -46,6 +47,7 @@ enum {
     CAMU_SCREEN_RESEEK,
     CAMU_SCREEN_SHUFFLE,
     CAMU_SCREEN_STATUS,
+    CAMU_SCREEN_PRINT,
 #ifdef CAMU_SCREEN_DEBUG_KEY
     CAMU_SCREEN_DEBUG,
 #endif
@@ -57,6 +59,34 @@ struct camu_screen_video {
     struct camu_video_buffer *buf;
 };
 
+enum {
+    CAMU_OSD_PAUSE = 1,
+    CAMU_OSD_SEEK = 1 << 1,
+    CAMU_OSD_VOLUME = 1 << 2,
+    CAMU_OSD_EMPTY = 1 << 3
+};
+
+enum {
+    CAMU_OSD_BAR_PROGRESS = 0,
+    CAMU_OSD_BAR_SEEK,
+    CAMU_OSD_BAR_VOLUME
+};
+
+#define CAMU_OSD_FLASH_FOR(s) (nn_get_tick() + s)
+
+struct camu_osd {
+    u32 show;
+    u8 shown_for;
+    bool show_binds;
+    u32 connecting;
+    u32 paused;
+    u32 bar_mode;
+    f64 bar;
+    f64 flash;
+    f64 pts;
+    u64 duration;
+};
+
 struct camu_screen {
     atomic(s32) state;
     struct stl_window *window;
@@ -86,6 +116,7 @@ struct camu_screen {
     u64 last_seek_ts;
 #endif
     bool touch_mode;
+    struct camu_osd osd;
     u8 vr_emulation;
     bool vr_left_eye;
     f64 vr_calibrate_x;
diff --git a/src/server/server.c b/src/server/server.c
index c547b5d..7781c05 100644
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -12,6 +12,7 @@
 #ifdef CAMU_HAVE_PORTAL
 #include "../portal/src/packet_ext.h"
 #endif
+#include "../codec/packet_ext.h"
 
 #include "server.h"
 #include "common.h"
@@ -334,7 +335,11 @@ static struct cch_entry *entry_from_post(struct camu_server *server, struct camu
     if (index <= post->media.count) {
         struct camu_post_media *media = &al_array_at(post->media, index);
         if (!al_str_is_empty(&media->url)) {
+#ifdef NAUNET_HAS_CURL
             entry = cch_handler_http_create(&media->url, server->loop);
+#else
+            (void)server;
+#endif
         }
     }
     if (!entry) {
@@ -528,6 +533,22 @@ static void client_portal_callback(void *userdata0, void *userdata1, struct camu
 }
 #endif
 
+static void maybe_send_visual_data(struct camu_server *server, struct nn_rpc_connection *conn, u32 node_id)
+{
+    struct camu_resource *resource = get_resource_by_node_id(server, node_id);
+    if (resource) {
+        struct lia_visual_data *visual = &resource->node->visual;
+        if (!visual->samples) return;
+        struct nn_packet *packet = nn_rpc_get_packet(conn->rpc, CAMU_CLIENT_VISUAL_DATA);
+        nn_packet_write_u32(packet, node_id);
+        nn_packet_write_audio_format(packet, &visual->fmt);
+        nn_packet_write_u32(packet, visual->size);
+        NNWT_PACKET_WRITE_DATA(packet, visual->samples, visual->size);
+        nn_packet_write_u32(packet, visual->count);
+        nn_rpc_connection_command(conn, packet, NULL, NULL);
+    }
+}
+
 static bool client_command_callback(void *userdata, struct nn_rpc_connection *conn,
     struct nn_packet *packet, struct nn_packet *rpacket)
 {
@@ -577,8 +598,7 @@ static bool client_command_callback(void *userdata, struct nn_rpc_connection *co
 #endif
     case CAMU_CLIENT_REQUEST_VISUAL_DATA: {
         u32 node_id = nn_packet_read_u32(packet);
-        struct camu_resource *resource = get_resource_by_node_id(server, node_id);
-        (void)resource;
+        maybe_send_visual_data(server, conn, node_id);
         break;
     }
     }
@@ -1004,3 +1024,8 @@ void camu_server_local_add(struct camu_server *server, struct nn_packet *packet)
 {
     handle_add_command(server, al_array_last(server->lists), packet);
 }
+
+void camu_server_local_set_index(struct camu_server *server, u32 index)
+{
+    lia_list_skipto(al_array_last(server->lists), LIANA_SEQUENCE_ANY, index);
+}
diff --git a/src/server/server.h b/src/server/server.h
index b1548f8..6552413 100644
--- a/src/server/server.h
+++ b/src/server/server.h
@@ -57,3 +57,4 @@ void camu_server_free(struct camu_server *server);
 
 // Local compat.
 void camu_server_local_add(struct camu_server *server, struct nn_packet *packet);
+void camu_server_local_set_index(struct camu_server *server, u32 index);
diff --git a/src/util/print_time.h b/src/util/print_time.h
index 89644b2..b6ab625 100644
--- a/src/util/print_time.h
+++ b/src/util/print_time.h
@@ -2,19 +2,29 @@
 
 #include <al/lib.h>
 
+static inline bool camu_split_time(u64 nanoseconds, u32 *hours, u32 *minutes, u32 *seconds, u32 *hundredths)
+{
+    *hours = nanoseconds / 3600000000u;
+    *minutes = nanoseconds / 60000000u;
+    *seconds = nanoseconds / 1000000u;
+    *hundredths = nanoseconds / 10000u;
+    bool over_an_hour = *minutes >= 60u;
+    *hundredths -= *seconds * 100u;
+    *seconds -= *minutes * 60u;
+    *minutes -= *hours * 60u;
+    return over_an_hour;
+}
+
 static inline s32 camu_print_time(char *buf, size_t size, u64 nanoseconds, bool always_show_hour, u32 hour_padding)
 {
-    u32 hours = nanoseconds / 3600000000u;
-    u32 minutes = nanoseconds / 60000000u;
-    bool show_hour = always_show_hour || minutes >= 60u;
-    u32 seconds = nanoseconds / 1000000u;
-    seconds -= minutes * 60u;
-    minutes -= hours * 60u;
+    u32 hours, minutes, seconds, hundredths;
+    bool show_hour = camu_split_time(nanoseconds, &hours, &minutes, &seconds, &hundredths);
+    show_hour |= always_show_hour;
     s32 offset = 0;
     if (show_hour && hour_padding >= 2 && hour_padding <= 4) {
         static const char *padding_table[] = { "%.2u:", "%.3u:", "%.4u:" };
         offset += al_snprintf(buf, size, padding_table[hour_padding - 2u], hours);
     }
-    offset += al_snprintf(buf + offset, size - offset, "%.2u:%.2u", minutes, seconds);
+    offset += al_snprintf(buf + offset, size - offset, "%.2u:%.2u.%.2u", minutes, seconds, hundredths);
     return offset;
 }
diff --git a/subprojects/stela.wrap b/subprojects/stela.wrap
index 40cb968..bafd02c 100644
--- a/subprojects/stela.wrap
+++ b/subprojects/stela.wrap
@@ -1,5 +1,5 @@
 [wrap-git]
-directory = stela-0c43dca
+directory = stela-9c4a7eb
 url = https://git.akon.city/stela.git
 push-url = git@git.akon.city:stela.git
-revision = 0c43dcac12f606c0ac46b5f87dd3de324ff9ef04
+revision = 9c4a7eb845126f068aaac0173453e803e5ea6bf8