From 6e242bb6757cef0832e35c4d2986f1e7dff3f1d1 Mon Sep 17 00:00:00 2001 From: tkrmagid Date: Sat, 16 May 2026 20:01:41 +0900 Subject: [PATCH] v0.4.15: split per-video vs total cache cap; auto-augment legacy config MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - max_preload_mb is now strictly the per-video download cap (default raised to 2048 MB so a single 4K short clip fits without hitting the wall). - New max_cache_mb knob caps total client-side cache directory size (default 750 MB, sized for ~50 short FHD clips). Enforced cooperatively at start of each /videoPreload download and during the read loop so a late-arriving large clip can't blow past the cap. - VideoPlayerConfig.load() now detects missing keys (max_preload_mb, max_cache_mb, render_distance_blocks) and rewrites the file once with defaults filled in, so existing servers pick up new options without having to delete config/video_player.json. - CachePolicyPayload now carries (maxPerVideoBytes, maxCacheBytes, renderDistanceBlocks); StreamCodec order: VAR_LONG, VAR_LONG, VAR_INT. - Client receiver wires both caps into VideoCache; chat errors distinguish "단일 영상 NMB 초과" vs "전체 캐시 NMB 초과". - Add dist/ to .gitignore (release artifacts uploaded to Gitea, never committed). Co-Authored-By: Claude Opus 4.7 --- .gitignore | 1 + gradle.properties | 2 +- .../ejclaw/videoplayer/VideoPlayerConfig.java | 60 +++++++++++-- .../ejclaw/videoplayer/VideoPlayerMod.java | 1 + .../client/net/ClientNetworking.java | 8 +- .../client/playback/VideoCache.java | 84 +++++++++++++++++-- .../videoplayer/net/CachePolicyPayload.java | 11 ++- 7 files changed, 146 insertions(+), 21 deletions(-) diff --git a/.gitignore b/.gitignore index e9c3f1a..34e5b7d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ .gradle/ build/ +dist/ out/ .idea/ .vscode/ diff --git a/gradle.properties b/gradle.properties index 06d6646..427e701 100644 --- a/gradle.properties +++ b/gradle.properties @@ -5,7 +5,7 @@ org.gradle.configuration-cache=false # Mod mod_id=video_player -mod_version=0.4.14 +mod_version=0.4.15 maven_group=com.ejclaw.videoplayer archives_base_name=video_player diff --git a/src/main/java/com/ejclaw/videoplayer/VideoPlayerConfig.java b/src/main/java/com/ejclaw/videoplayer/VideoPlayerConfig.java index 886efce..1af66ed 100644 --- a/src/main/java/com/ejclaw/videoplayer/VideoPlayerConfig.java +++ b/src/main/java/com/ejclaw/videoplayer/VideoPlayerConfig.java @@ -50,15 +50,21 @@ public final class VideoPlayerConfig { private static final String FILE_NAME = "video_player.json"; /** - * Default per-video download cap in MB. Sized to comfortably fit ~50 short FHD clips: - * FHD H.264 at ~5 Mbps × 20 s ≈ 12.5 MB, so 50 × 15 MB ≈ 750 MB with headroom for - * higher-bitrate sources. + * Default per-video download cap in MB. Sized to allow a single 4K short clip + * (≈25 Mbps × 60 s ≈ 190 MB, with headroom for higher-bitrate sources). Per-video + * cap is intentionally separate from the total-cache cap below. */ - private static final int DEFAULT_MAX_PRELOAD_MB = 750; + private static final int DEFAULT_MAX_PRELOAD_MB = 2048; + /** + * Default total-cache cap in MB. Sized to comfortably fit ~50 short FHD clips: + * FHD H.264 at ~5 Mbps × 20 s ≈ 12.5 MB, so 50 × 15 MB ≈ 750 MB with headroom. + */ + private static final int DEFAULT_MAX_CACHE_MB = 750; /** Default render-distance cap for video anchors, in blocks. 128 = the legacy hard-coded value. */ private static final int DEFAULT_RENDER_DISTANCE = 128; private static volatile int maxPreloadMb = DEFAULT_MAX_PRELOAD_MB; + private static volatile int maxCacheMb = DEFAULT_MAX_CACHE_MB; private static volatile int renderDistanceBlocks = DEFAULT_RENDER_DISTANCE; private static volatile List preloadUrls = Collections.emptyList(); /** Insertion-ordered name → url. Mutated only under the class monitor. */ @@ -73,6 +79,7 @@ public final class VideoPlayerConfig { VideoPlayerMod.LOG.info("[{}] created default config at {}", VideoPlayerMod.MOD_ID, path); maxPreloadMb = DEFAULT_MAX_PRELOAD_MB; + maxCacheMb = DEFAULT_MAX_CACHE_MB; preloadUrls = Collections.emptyList(); CACHE_ENTRIES.clear(); return; @@ -80,21 +87,41 @@ public final class VideoPlayerConfig { String raw = Files.readString(path, StandardCharsets.UTF_8); JsonObject json = JsonParser.parseString(raw).getAsJsonObject(); - // max_preload_mb (sanity-clamped to [16, 16384] so a typo can't brick a client) + // Track whether any expected key was missing; if so, we rewrite the file at the + // end so users don't have to delete their config to pick up new options. + boolean augmented = false; + + // max_preload_mb (per-video cap, sanity-clamped to [16, 16384]) int cap = DEFAULT_MAX_PRELOAD_MB; if (json.has("max_preload_mb") && json.get("max_preload_mb").isJsonPrimitive() && json.get("max_preload_mb").getAsJsonPrimitive().isNumber()) { cap = json.get("max_preload_mb").getAsInt(); + } else { + augmented = true; } if (cap < 16) cap = 16; if (cap > 16384) cap = 16384; maxPreloadMb = cap; + // max_cache_mb (total-cache cap, sanity-clamped to [16, 65536]) + int total = DEFAULT_MAX_CACHE_MB; + if (json.has("max_cache_mb") && json.get("max_cache_mb").isJsonPrimitive() + && json.get("max_cache_mb").getAsJsonPrimitive().isNumber()) { + total = json.get("max_cache_mb").getAsInt(); + } else { + augmented = true; + } + if (total < 16) total = 16; + if (total > 65536) total = 65536; + maxCacheMb = total; + // render_distance_blocks (sanity-clamped to [16, 2048]) int rd = DEFAULT_RENDER_DISTANCE; if (json.has("render_distance_blocks") && json.get("render_distance_blocks").isJsonPrimitive() && json.get("render_distance_blocks").getAsJsonPrimitive().isNumber()) { rd = json.get("render_distance_blocks").getAsInt(); + } else { + augmented = true; } if (rd < 16) rd = 16; if (rd > 2048) rd = 2048; @@ -134,12 +161,23 @@ public final class VideoPlayerConfig { } VideoPlayerMod.LOG.info( - "[{}] config loaded: cap={} MB, render={} blocks, preload_urls={}, cache_entries={}", - VideoPlayerMod.MOD_ID, maxPreloadMb, renderDistanceBlocks, urls.size(), CACHE_ENTRIES.size()); + "[{}] config loaded: per-video={} MB, total-cache={} MB, render={} blocks, " + + "preload_urls={}, cache_entries={}", + VideoPlayerMod.MOD_ID, maxPreloadMb, maxCacheMb, renderDistanceBlocks, + urls.size(), CACHE_ENTRIES.size()); + + // Auto-augment: rewrite the file once so missing keys appear after a mod update. + if (augmented) { + VideoPlayerMod.LOG.info( + "[{}] config missing one or more keys — rewriting with defaults filled in", + VideoPlayerMod.MOD_ID); + save(); + } } catch (Throwable t) { VideoPlayerMod.LOG.warn("[{}] failed to read config {}: {} — using defaults", VideoPlayerMod.MOD_ID, path, t.toString()); maxPreloadMb = DEFAULT_MAX_PRELOAD_MB; + maxCacheMb = DEFAULT_MAX_CACHE_MB; renderDistanceBlocks = DEFAULT_RENDER_DISTANCE; preloadUrls = Collections.emptyList(); CACHE_ENTRIES.clear(); @@ -154,6 +192,12 @@ public final class VideoPlayerConfig { /** Same value in bytes. */ public static long maxPreloadBytes() { return (long) maxPreloadMb * 1024L * 1024L; } + /** Hard cap on the client-side total cache directory, in MB. */ + public static int maxCacheMb() { return maxCacheMb; } + + /** Same value in bytes. */ + public static long maxCacheBytes() { return (long) maxCacheMb * 1024L * 1024L; } + /** Anchor BE view-distance cap, in blocks. */ public static int renderDistanceBlocks() { return renderDistanceBlocks; } @@ -234,10 +278,12 @@ public final class VideoPlayerConfig { JsonObject root = new JsonObject(); root.addProperty("_comment", "max_preload_mb: per-video download cap (each client). " + + "max_cache_mb: total cache directory cap (each client). " + "render_distance_blocks: max distance at which a video anchor still renders. " + "preload_urls: HTTP(S) videos auto-pushed to every player on join (no name). " + "cache_entries: named entries managed by /videoCache add|list|remove."); root.addProperty("max_preload_mb", DEFAULT_MAX_PRELOAD_MB); + root.addProperty("max_cache_mb", DEFAULT_MAX_CACHE_MB); root.addProperty("render_distance_blocks", DEFAULT_RENDER_DISTANCE); root.add("preload_urls", new JsonArray()); root.add("cache_entries", new JsonArray()); diff --git a/src/main/java/com/ejclaw/videoplayer/VideoPlayerMod.java b/src/main/java/com/ejclaw/videoplayer/VideoPlayerMod.java index 59b53be..3a99479 100644 --- a/src/main/java/com/ejclaw/videoplayer/VideoPlayerMod.java +++ b/src/main/java/com/ejclaw/videoplayer/VideoPlayerMod.java @@ -50,6 +50,7 @@ public class VideoPlayerMod implements ModInitializer { var player = handler.getPlayer(); ServerPlayNetworking.send(player, new CachePolicyPayload( VideoPlayerConfig.maxPreloadBytes(), + VideoPlayerConfig.maxCacheBytes(), VideoPlayerConfig.renderDistanceBlocks())); int sent = 0; diff --git a/src/main/java/com/ejclaw/videoplayer/client/net/ClientNetworking.java b/src/main/java/com/ejclaw/videoplayer/client/net/ClientNetworking.java index e8ff10c..20e6ed7 100644 --- a/src/main/java/com/ejclaw/videoplayer/client/net/ClientNetworking.java +++ b/src/main/java/com/ejclaw/videoplayer/client/net/ClientNetworking.java @@ -44,10 +44,12 @@ public final class ClientNetworking { VideoCache.preload(payload.url()); }); - // Server tells us the per-video download cap (bytes). Must arrive before PreloadPayload - // (the server sends policy first on JOIN), so we don't accidentally use the stale default. + // Server tells us the per-video and total-cache download caps (bytes). Must arrive + // before PreloadPayload (server sends policy first on JOIN) so we don't use stale + // defaults. ClientPlayNetworking.registerGlobalReceiver(CachePolicyPayload.TYPE, (payload, context) -> { - VideoCache.setMaxBytes(payload.maxBytes()); + VideoCache.setMaxBytes(payload.maxPerVideoBytes()); + VideoCache.setMaxCacheBytes(payload.maxCacheBytes()); ClientPolicy.setRenderDistanceBlocks(payload.renderDistanceBlocks()); }); diff --git a/src/main/java/com/ejclaw/videoplayer/client/playback/VideoCache.java b/src/main/java/com/ejclaw/videoplayer/client/playback/VideoCache.java index 11d387d..abce1e6 100644 --- a/src/main/java/com/ejclaw/videoplayer/client/playback/VideoCache.java +++ b/src/main/java/com/ejclaw/videoplayer/client/playback/VideoCache.java @@ -42,18 +42,36 @@ public final class VideoCache { private static final Set IN_FLIGHT = ConcurrentHashMap.newKeySet(); /** - * Hard ceiling on a single preload, in bytes. Default 750 MB sized to fit ~50 short FHD - * clips; overridden per-session by {@link com.ejclaw.videoplayer.net.CachePolicyPayload} + * Hard ceiling on a single preload, in bytes. Default 2 GB sized to allow a single 4K + * short clip; overridden per-session by {@link com.ejclaw.videoplayer.net.CachePolicyPayload} * on join, which carries the server's {@code max_preload_mb} config value. */ - private static volatile long MAX_BYTES = 750L * 1024 * 1024; + private static volatile long MAX_BYTES = 2048L * 1024 * 1024; + + /** + * Hard ceiling on the total cache directory size, in bytes. Default 750 MB sized to fit + * ~50 short FHD clips; overridden per-session by {@link com.ejclaw.videoplayer.net.CachePolicyPayload} + * on join, which carries the server's {@code max_cache_mb} config value. Enforced + * cooperatively at the start of each download — running cache + new download must stay + * within this cap. + */ + private static volatile long MAX_CACHE_BYTES = 750L * 1024 * 1024; /** Server-driven override of the per-video cap. */ public static void setMaxBytes(long bytes) { if (bytes < 16L * 1024 * 1024) bytes = 16L * 1024 * 1024; if (bytes > 16L * 1024 * 1024 * 1024) bytes = 16L * 1024 * 1024 * 1024; MAX_BYTES = bytes; - VideoPlayerMod.LOG.info("[{}] preload cap set to {} MB", + VideoPlayerMod.LOG.info("[{}] per-video preload cap set to {} MB", + VideoPlayerMod.MOD_ID, bytes / (1024 * 1024)); + } + + /** Server-driven override of the total-cache cap. */ + public static void setMaxCacheBytes(long bytes) { + if (bytes < 16L * 1024 * 1024) bytes = 16L * 1024 * 1024; + if (bytes > 64L * 1024 * 1024 * 1024) bytes = 64L * 1024 * 1024 * 1024; + MAX_CACHE_BYTES = bytes; + VideoPlayerMod.LOG.info("[{}] total-cache cap set to {} MB", VideoPlayerMod.MOD_ID, bytes / (1024 * 1024)); } @@ -151,6 +169,22 @@ public final class VideoCache { return; } + // Total-cache check: refuse to start if the cache directory is already at the cap. + // We re-check during the read loop too, since other downloads may be in flight in + // parallel. {@code existingCacheBytes} excludes our own .part (which we just wrote 0 + // bytes to / haven't created yet). + long existingCacheBytes = cacheDirSize(cacheDir, partPath); + if (existingCacheBytes >= MAX_CACHE_BYTES) { + long capMb = MAX_CACHE_BYTES / (1024 * 1024); + long usedMb = existingCacheBytes / (1024 * 1024); + VideoPlayerMod.LOG.warn( + "[{}] preload: total-cache cap reached ({}/{} MB); aborting {}", + VideoPlayerMod.MOD_ID, usedMb, capMb, url); + notifyChat("[videopreload] 실패 (전체 캐시 " + capMb + "MB 초과 / 현재 " + + usedMb + "MB): " + url, ChatFormatting.RED); + return; + } + URLConnection raw = URI.create(url).toURL().openConnection(); raw.setConnectTimeout(10_000); raw.setReadTimeout(30_000); @@ -176,10 +210,22 @@ public final class VideoCache { if (total > MAX_BYTES) { long capMb = MAX_BYTES / (1024 * 1024); VideoPlayerMod.LOG.warn( - "[{}] preload: {} exceeded {} MB cap; aborting", + "[{}] preload: {} exceeded per-video {} MB cap; aborting", VideoPlayerMod.MOD_ID, url, capMb); try { Files.deleteIfExists(partPath); } catch (Throwable ignored) {} - notifyChat("[videopreload] 실패 (" + capMb + "MB 초과): " + url, ChatFormatting.RED); + notifyChat("[videopreload] 실패 (단일 영상 " + capMb + "MB 초과): " + url, + ChatFormatting.RED); + return; + } + if (existingCacheBytes + total > MAX_CACHE_BYTES) { + long capMb = MAX_CACHE_BYTES / (1024 * 1024); + long usedMb = (existingCacheBytes + total) / (1024 * 1024); + VideoPlayerMod.LOG.warn( + "[{}] preload: total-cache cap exceeded ({}>{} MB); aborting {}", + VideoPlayerMod.MOD_ID, usedMb, capMb, url); + try { Files.deleteIfExists(partPath); } catch (Throwable ignored) {} + notifyChat("[videopreload] 실패 (전체 캐시 " + capMb + "MB 초과): " + url, + ChatFormatting.RED); return; } out.write(buf, 0, n); @@ -213,6 +259,32 @@ public final class VideoCache { }); } + /** + * Sum of regular-file sizes under {@code dir}, skipping {@code excludePart} (the .part file + * for the in-flight download — we account for that via the running {@code total} counter). + * Best-effort: errors collapse to 0 so a transient FS hiccup doesn't strand a download. + */ + private static long cacheDirSize(Path dir, Path excludePart) { + if (dir == null) return 0L; + try { + if (!Files.isDirectory(dir)) return 0L; + final long[] sum = { 0L }; + try (var stream = Files.newDirectoryStream(dir)) { + for (Path p : stream) { + if (excludePart != null && p.equals(excludePart)) continue; + try { + if (Files.isRegularFile(p)) sum[0] += Files.size(p); + } catch (Throwable ignored) {} + } + } + return sum[0]; + } catch (Throwable t) { + VideoPlayerMod.LOG.warn("[{}] cacheDirSize failed: {}", + VideoPlayerMod.MOD_ID, t.toString()); + return 0L; + } + } + private static Path cacheDir() { Minecraft mc = Minecraft.getInstance(); if (mc == null || mc.gameDirectory == null) return null; diff --git a/src/main/java/com/ejclaw/videoplayer/net/CachePolicyPayload.java b/src/main/java/com/ejclaw/videoplayer/net/CachePolicyPayload.java index 8a4505e..07b7a91 100644 --- a/src/main/java/com/ejclaw/videoplayer/net/CachePolicyPayload.java +++ b/src/main/java/com/ejclaw/videoplayer/net/CachePolicyPayload.java @@ -9,15 +9,18 @@ import net.minecraft.resources.Identifier; /** * S2C — broadcasts the server-configured client-side policy bundle on join, before any - * {@link PreloadPayload}. Currently carries: {@code maxBytes} (per-video download cap) and - * {@code renderDistanceBlocks} (anchor BE view-distance cap). + * {@link PreloadPayload}. Carries: {@code maxPerVideoBytes} (per-video download cap), + * {@code maxCacheBytes} (total-cache directory cap), and {@code renderDistanceBlocks} + * (anchor BE view-distance cap). */ -public record CachePolicyPayload(long maxBytes, int renderDistanceBlocks) implements CustomPacketPayload { +public record CachePolicyPayload(long maxPerVideoBytes, long maxCacheBytes, int renderDistanceBlocks) + implements CustomPacketPayload { public static final CustomPacketPayload.Type TYPE = new CustomPacketPayload.Type<>(Identifier.fromNamespaceAndPath(VideoPlayerMod.MOD_ID, "cache_policy")); public static final StreamCodec CODEC = StreamCodec.composite( - ByteBufCodecs.VAR_LONG, CachePolicyPayload::maxBytes, + ByteBufCodecs.VAR_LONG, CachePolicyPayload::maxPerVideoBytes, + ByteBufCodecs.VAR_LONG, CachePolicyPayload::maxCacheBytes, ByteBufCodecs.VAR_INT, CachePolicyPayload::renderDistanceBlocks, CachePolicyPayload::new );