Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
e31635ef24 | ||
|
|
7364e010ac |
@@ -5,7 +5,7 @@ org.gradle.configuration-cache=false
|
||||
|
||||
# Mod
|
||||
mod_id=video_player
|
||||
mod_version=0.4.31
|
||||
mod_version=0.4.33
|
||||
maven_group=com.ejclaw.videoplayer
|
||||
archives_base_name=video_player
|
||||
|
||||
|
||||
@@ -100,17 +100,22 @@ public class VideoPlayerClient implements ClientModInitializer {
|
||||
*
|
||||
* <p>Gain is also gated by the Minecraft sound options so the in-game sliders work as
|
||||
* expected: vanilla {@code SoundEngine.calculateVolume} multiplies by master × category, so
|
||||
* we do the same with {@link SoundSource#PLAYERS} as the category. Result: dragging the
|
||||
* "Players" slider in Options → Music & Sounds attenuates video audio just like other
|
||||
* player sounds, and "Master" still gates everything.
|
||||
* we do the same. The category is configurable via {@code sound_category} in
|
||||
* {@code config/video_player.json} (default {@link SoundSource#RECORDS} = the "Jukebox/Note
|
||||
* Blocks" slider, since video playback is media). Master always gates on top; when the
|
||||
* configured category is Master itself we don't square it. Result: dragging the configured
|
||||
* category's slider in Options → Music & Sounds attenuates video audio, and "Master"
|
||||
* still gates everything.
|
||||
*/
|
||||
private static void updateDistanceGains(Minecraft client) {
|
||||
LocalPlayer p = client.player;
|
||||
if (p == null || client.level == null) return;
|
||||
Vec3 eye = p.getEyePosition();
|
||||
float masterVol = client.options.getSoundSourceVolume(SoundSource.MASTER);
|
||||
float playersVol = client.options.getSoundSourceVolume(SoundSource.PLAYERS);
|
||||
float categoryScale = masterVol * playersVol;
|
||||
SoundSource category = VideoPlayerConfig.soundCategory();
|
||||
float categoryScale = (category == SoundSource.MASTER)
|
||||
? masterVol
|
||||
: masterVol * client.options.getSoundSourceVolume(category);
|
||||
for (BlockPos pos : VideoPlayback.activePositions()) {
|
||||
if (!(client.level.getBlockEntity(pos) instanceof VideoAnchorBlockEntity be)) continue;
|
||||
Vec3 center = be.panelCenter();
|
||||
|
||||
@@ -7,6 +7,7 @@ import com.google.gson.JsonElement;
|
||||
import com.google.gson.JsonObject;
|
||||
import com.google.gson.JsonParser;
|
||||
import net.fabricmc.loader.api.FabricLoader;
|
||||
import net.minecraft.sounds.SoundSource;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
@@ -62,10 +63,17 @@ public final class VideoPlayerConfig {
|
||||
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;
|
||||
/**
|
||||
* Default Minecraft sound category the client uses to gate video audio. RECORDS = the
|
||||
* "Jukebox/Note Blocks" (음반) slider — video playback is media, so it belongs there rather
|
||||
* than on the player-sound slider. Master always gates on top of whatever category is set.
|
||||
*/
|
||||
private static final SoundSource DEFAULT_SOUND_CATEGORY = SoundSource.RECORDS;
|
||||
|
||||
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 SoundSource soundCategory = DEFAULT_SOUND_CATEGORY;
|
||||
private static volatile List<String> preloadUrls = Collections.emptyList();
|
||||
/** Insertion-ordered name → url. Mutated only under the class monitor. */
|
||||
private static final Map<String, String> CACHE_ENTRIES = new LinkedHashMap<>();
|
||||
@@ -80,6 +88,8 @@ public final class VideoPlayerConfig {
|
||||
VideoPlayerMod.MOD_ID, path);
|
||||
maxPreloadMb = DEFAULT_MAX_PRELOAD_MB;
|
||||
maxCacheMb = DEFAULT_MAX_CACHE_MB;
|
||||
renderDistanceBlocks = DEFAULT_RENDER_DISTANCE;
|
||||
soundCategory = DEFAULT_SOUND_CATEGORY;
|
||||
preloadUrls = Collections.emptyList();
|
||||
CACHE_ENTRIES.clear();
|
||||
return;
|
||||
@@ -127,6 +137,23 @@ public final class VideoPlayerConfig {
|
||||
if (rd > 2048) rd = 2048;
|
||||
renderDistanceBlocks = rd;
|
||||
|
||||
// sound_category (client uses this to pick which volume slider gates video audio)
|
||||
SoundSource cat = DEFAULT_SOUND_CATEGORY;
|
||||
if (json.has("sound_category") && json.get("sound_category").isJsonPrimitive()
|
||||
&& json.get("sound_category").getAsJsonPrimitive().isString()) {
|
||||
SoundSource parsed = parseSoundSource(json.get("sound_category").getAsString());
|
||||
if (parsed != null) {
|
||||
cat = parsed;
|
||||
} else {
|
||||
VideoPlayerMod.LOG.warn("[{}] config: unknown sound_category '{}' — using '{}'",
|
||||
VideoPlayerMod.MOD_ID, json.get("sound_category").getAsString(),
|
||||
DEFAULT_SOUND_CATEGORY.getName());
|
||||
}
|
||||
} else {
|
||||
augmented = true;
|
||||
}
|
||||
soundCategory = cat;
|
||||
|
||||
// preload_urls (legacy)
|
||||
List<String> urls = new ArrayList<>();
|
||||
if (json.has("preload_urls") && json.get("preload_urls").isJsonArray()) {
|
||||
@@ -162,9 +189,9 @@ public final class VideoPlayerConfig {
|
||||
|
||||
VideoPlayerMod.LOG.info(
|
||||
"[{}] config loaded: per-video={} MB, total-cache={} MB, render={} blocks, "
|
||||
+ "preload_urls={}, cache_entries={}",
|
||||
+ "sound_category={}, preload_urls={}, cache_entries={}",
|
||||
VideoPlayerMod.MOD_ID, maxPreloadMb, maxCacheMb, renderDistanceBlocks,
|
||||
urls.size(), CACHE_ENTRIES.size());
|
||||
soundCategory.getName(), urls.size(), CACHE_ENTRIES.size());
|
||||
|
||||
// Auto-augment: rewrite the file once so missing keys appear after a mod update.
|
||||
if (augmented) {
|
||||
@@ -179,11 +206,23 @@ public final class VideoPlayerConfig {
|
||||
maxPreloadMb = DEFAULT_MAX_PRELOAD_MB;
|
||||
maxCacheMb = DEFAULT_MAX_CACHE_MB;
|
||||
renderDistanceBlocks = DEFAULT_RENDER_DISTANCE;
|
||||
soundCategory = DEFAULT_SOUND_CATEGORY;
|
||||
preloadUrls = Collections.emptyList();
|
||||
CACHE_ENTRIES.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/** Match a config string against {@link SoundSource#getName()} (case-insensitive). Null = no match. */
|
||||
private static SoundSource parseSoundSource(String s) {
|
||||
if (s == null) return null;
|
||||
String t = s.trim();
|
||||
if (t.isEmpty()) return null;
|
||||
for (SoundSource src : SoundSource.values()) {
|
||||
if (src.getName().equalsIgnoreCase(t)) return src;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// -- accessors ---------------------------------------------------------------------------
|
||||
|
||||
/** Hard cap on a single client-side video download, in MB. */
|
||||
@@ -201,6 +240,12 @@ public final class VideoPlayerConfig {
|
||||
/** Anchor BE view-distance cap, in blocks. */
|
||||
public static int renderDistanceBlocks() { return renderDistanceBlocks; }
|
||||
|
||||
/**
|
||||
* Minecraft sound category the client gates video audio with (default {@link SoundSource#RECORDS}).
|
||||
* Read client-side from the local config; not pushed from the server.
|
||||
*/
|
||||
public static SoundSource soundCategory() { return soundCategory; }
|
||||
|
||||
/** Legacy un-named preload list (still pushed at join). Never null. */
|
||||
public static List<String> preloadUrls() { return preloadUrls; }
|
||||
|
||||
@@ -280,11 +325,15 @@ public final class VideoPlayerConfig {
|
||||
"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. "
|
||||
+ "sound_category: which Minecraft volume slider gates video audio (client-side). "
|
||||
+ "One of: master, music, record, weather, block, hostile, neutral, player, "
|
||||
+ "ambient, voice, ui. Default 'record' = the Jukebox/Note Blocks slider. "
|
||||
+ "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.addProperty("sound_category", DEFAULT_SOUND_CATEGORY.getName());
|
||||
root.add("preload_urls", new JsonArray());
|
||||
root.add("cache_entries", new JsonArray());
|
||||
Gson gson = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
|
||||
@@ -301,11 +350,15 @@ public final class VideoPlayerConfig {
|
||||
"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. "
|
||||
+ "sound_category: which Minecraft volume slider gates video audio (client-side). "
|
||||
+ "One of: master, music, record, weather, block, hostile, neutral, player, "
|
||||
+ "ambient, voice, ui. Default 'record' = the Jukebox/Note Blocks slider. "
|
||||
+ "preload_urls: legacy un-named auto-preload list. "
|
||||
+ "cache_entries: managed by /videoCache add|list|remove.");
|
||||
root.addProperty("max_preload_mb", maxPreloadMb);
|
||||
root.addProperty("max_cache_mb", maxCacheMb);
|
||||
root.addProperty("render_distance_blocks", renderDistanceBlocks);
|
||||
root.addProperty("sound_category", soundCategory.getName());
|
||||
JsonArray legacyArr = new JsonArray();
|
||||
for (String u : preloadUrls) legacyArr.add(u);
|
||||
root.add("preload_urls", legacyArr);
|
||||
|
||||
@@ -276,6 +276,14 @@ public class JavaCvBackend implements VideoBackend {
|
||||
Class<?> frameCls = Class.forName(FRAME_CLASS);
|
||||
Field imageField = frameCls.getField("image");
|
||||
Field samplesField = frameCls.getField("samples");
|
||||
// Row stride (bytes) of frame.image[0]. swscale aligns the RGBA linesize to a SIMD
|
||||
// boundary (32/64 B), so for any width whose width*4 isn't already aligned the plane
|
||||
// is padded: e.g. 1674-wide → linesize 6720 instead of 6696. We read this to strip
|
||||
// the padding row-by-row; resolved defensively so a Frame without the field just
|
||||
// falls back to deriving the stride from the buffer size below.
|
||||
Field strideField;
|
||||
try { strideField = frameCls.getField("imageStride"); }
|
||||
catch (Throwable t) { strideField = null; }
|
||||
// Java2DFrameConverter is no longer used now that we read RGBA bytes directly,
|
||||
// but we still resolve its class so a future code path could fall back to it if a
|
||||
// grabber refuses setPixelFormat. Keep the lookup defensive.
|
||||
@@ -323,26 +331,40 @@ public class JavaCvBackend implements VideoBackend {
|
||||
// primary memory-churn problem; 0.4.10 fixed that; 0.4.11 adds the ring on
|
||||
// top to absorb the burst-then-stall caused by SourceDataLine backpressure
|
||||
// pacing only at audio-buffer granularity.
|
||||
int need = src.remaining();
|
||||
// Reviewer-mandated sanity bounds: memCopy is a raw native copy with no
|
||||
// fence against overrun. Validate against (a) the source buffer's own
|
||||
// capacity (so a corrupt plane can't read past it) and (b) the expected
|
||||
// RGBA frame size (width*height*4) (so an unexpectedly oversized plane
|
||||
// can't smash the dst slot we'll allocate). If either fails, skip this
|
||||
// frame and continue — the next grab() will give us a fresh one.
|
||||
int expected = width * height * 4;
|
||||
if (need > src.capacity()) {
|
||||
VideoPlayerMod.LOG.warn("[{}] frame overruns source capacity (need={}, cap={}); skipping",
|
||||
VideoPlayerMod.MOD_ID, need, src.capacity());
|
||||
need = 0;
|
||||
} else if (need > expected) {
|
||||
VideoPlayerMod.LOG.warn("[{}] frame larger than expected RGBA size (need={}, expected={}); skipping",
|
||||
VideoPlayerMod.MOD_ID, need, expected);
|
||||
need = 0;
|
||||
// The destination texture is tightly packed: one frame = width*height*4
|
||||
// bytes with no row padding (consumeFrame copies ringBytes[idx] straight
|
||||
// into a w*h*4 GPU texture and rejects anything larger). swscale, however,
|
||||
// hands us an RGBA plane whose linesize is SIMD-aligned, so for any width
|
||||
// where width*4 isn't a multiple of the alignment the source rows carry
|
||||
// trailing padding (e.g. 1674-wide → 6720 B/row vs the 6696 B we want).
|
||||
// Copying the padded buffer verbatim both overruns the tight dst slot and
|
||||
// shears the image; we must strip the pad row-by-row.
|
||||
int rowBytes = width * 4; // bytes of real pixels per row
|
||||
int dstBytes = rowBytes * height; // tightly-packed frame size
|
||||
// Source row stride: prefer Frame.imageStride (authoritative), else derive
|
||||
// it from the buffer size. Guard against a stride smaller than a full row
|
||||
// (bogus field) by falling back to the tight rowBytes.
|
||||
int strideBytes = rowBytes;
|
||||
if (strideField != null) {
|
||||
try {
|
||||
int s = strideField.getInt(frame);
|
||||
if (s >= rowBytes) strideBytes = s;
|
||||
} catch (Throwable ignored) {}
|
||||
} else if (height > 0) {
|
||||
int s = src.remaining() / height;
|
||||
if (s >= rowBytes) strideBytes = s;
|
||||
}
|
||||
if (need > 0) {
|
||||
// Sanity bound: the strided read must stay within the source buffer. memCopy
|
||||
// is a raw native copy with no overrun fence, so if the plane is smaller than
|
||||
// stride*height (corrupt/truncated) skip this frame and grab a fresh one.
|
||||
boolean ok = dstBytes > 0 && (long) strideBytes * height <= src.capacity();
|
||||
if (!ok && dstBytes > 0) {
|
||||
VideoPlayerMod.LOG.warn("[{}] frame plane too small (stride={}, h={}, cap={}); skipping",
|
||||
VideoPlayerMod.MOD_ID, strideBytes, height, src.capacity());
|
||||
}
|
||||
if (ok) {
|
||||
int srcPos = src.position();
|
||||
long srcAddr = MemoryUtil.memAddress(src) + srcPos;
|
||||
long srcBase = MemoryUtil.memAddress(src) + srcPos;
|
||||
synchronized (frameLock) {
|
||||
// Recheck shutdown inside the lock: stopWorker() flipped running=false
|
||||
// before signaling, so worker is the only writer here and grabber.close()
|
||||
@@ -350,12 +372,21 @@ public class JavaCvBackend implements VideoBackend {
|
||||
// the contract obvious to future readers.
|
||||
if (!running.get() || closed) break;
|
||||
int idx = ringTail;
|
||||
if (ringBufs[idx] == null || ringBufs[idx].capacity() < need) {
|
||||
ringBufs[idx] = ByteBuffer.allocateDirect(need).order(ByteOrder.nativeOrder());
|
||||
if (ringBufs[idx] == null || ringBufs[idx].capacity() < dstBytes) {
|
||||
ringBufs[idx] = ByteBuffer.allocateDirect(dstBytes).order(ByteOrder.nativeOrder());
|
||||
}
|
||||
long dstAddr = MemoryUtil.memAddress(ringBufs[idx]);
|
||||
MemoryUtil.memCopy(srcAddr, dstAddr, need);
|
||||
ringBytes[idx] = need;
|
||||
long dstBase = MemoryUtil.memAddress(ringBufs[idx]);
|
||||
if (strideBytes == rowBytes) {
|
||||
MemoryUtil.memCopy(srcBase, dstBase, dstBytes);
|
||||
} else {
|
||||
// Strip swscale row padding: copy only the real pixels per row.
|
||||
for (int y = 0; y < height; y++) {
|
||||
MemoryUtil.memCopy(srcBase + (long) y * strideBytes,
|
||||
dstBase + (long) y * rowBytes,
|
||||
rowBytes);
|
||||
}
|
||||
}
|
||||
ringBytes[idx] = dstBytes;
|
||||
ringTail = (idx + 1) % FRAME_RING_SLOTS;
|
||||
if (ringCount < FRAME_RING_SLOTS) {
|
||||
ringCount++;
|
||||
|
||||
Reference in New Issue
Block a user