swing-ui 0.1.25 → 1.0.1

package/ui-process-manager.js

@@ -0,0 +1,317 @@
+/**
+ * IPC Proxy worker
+ */
+
+import {parentPort, workerData} from "node:worker_threads";
+import path from "node:path";
+
+const env = workerData.runtime === "deno" ? Deno.env.toObject() : process.env;
+const responsePort = workerData.responsePort;
+const sharedBuffSignal = workerData.signalBuffer;
+
+const WorkerSignalIndex = {ExecutionControl: 0, WorkerControl: 1, DataLength: 2, ReceivedBytes: 3, SentBytes: 4};
+const WorkerSignal = {Resume: 0, Pause: 1, SendLine: 2, Block: 3, Unblock: 4, SendBytes: 5};
+
+const decoder = new TextDecoder("utf-8");
+const encoder = new TextEncoder();
+
+let jarProcess = null;
+let stdinWriter = null; // writer needed for Deno spawned process
+let ready = false;
+let lineBuffer = "";
+
+let syncMode = false;
+let exiting = false;
+
+if(workerData.runtime === "bun")
+{
+	console.log = (...args) => {
+		if(typeof args[0] === "object")
+		{
+			if(args[0] instanceof Error)
+			{
+				args[0] = args[0].stack;
+			}
+			else
+			{
+				args[0] = args[0].toString();
+			}
+		}
+		process.stdout.write(`${args[0]}\n`);
+	};
+	console.error = console.log;
+}
+else
+{
+	// Override console.log, console.error, etc. for logging to the main thread
+	["log", "error", "warn", "info", "debug"].forEach(method => {
+		console[method] = (...args) => {
+			parentPort.postMessage({type: `worker_${method}`, data: args[0]});
+		};
+	});
+}
+
+async function startJar()
+{
+	let JAR_PATH = path.join(workerData.moduleDir, "jar/gui-11.jar");
+	let JAVA_BIN = env.JAVA_HOME ? path.join(env.JAVA_HOME, workerData.os === "windows" ? "java.exe" : "java") : "java"; // build custom path from specified dir for each OS, or just use default command.
+	let JAVA_OPTS = (env.JAVA_OPTS ?? "").split(" ").filter(Boolean);
+	if(JAVA_OPTS.indexOf("-Dfile.encoding=UTF-8") === -1) JAVA_OPTS.push("-Dfile.encoding=UTF-8"); // important
+	if(workerData.debugJava) JAVA_OPTS.push("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005"); // for debugging JAR
+	if(workerData.os === "linux")  JAVA_OPTS.push("--add-opens=java.desktop/sun.awt.X11=ALL-UNNAMED"); // to be able to set WM_CLASS to project name in Java GUI
+	
+	const _opts = [...JAVA_OPTS, "-jar", JAR_PATH, "--root-dir", workerData.rootDir, "--module-dir", workerData.moduleDir];
+
+	if(workerData.verbose) _opts.push("--v");
+
+	try
+	{
+		if(workerData.runtime === "bun")
+		{
+			_opts.unshift(JAVA_BIN);
+			
+			try
+			{
+				jarProcess = Bun.spawn({
+					cmd: _opts,
+					stdin: "pipe",
+					stdout: "pipe",
+					stderr: "pipe",
+					env: env
+				});
+			}catch(ex)
+			{
+				console.error("Process Spawn Failed: ");
+				console.error(ex);
+				return;
+			}
+			
+			jarProcess.exited.then((code) => {
+				if(!exiting) console.error(`[jar-worker] GUI exited with code ${code}`);
+				ready = false;
+				parentPort.postMessage({type: "exit", code});
+			});
+			
+			// Read stdout
+			(async () => {
+				for await (const chunk of jarProcess.stdout)
+				{
+					lineBuffer += decoder.decode(chunk);
+					let i;
+					while((i = lineBuffer.indexOf("\n")) !== -1)
+					{
+						const line = lineBuffer.slice(0, i).trim();
+						lineBuffer = lineBuffer.slice(i + 1);
+						if(line.length > 0)
+						{
+							if(line.startsWith("eyJ")) // line.startsWith("{\"")
+							{
+								handleJarLine(line);
+							}
+							else
+							{
+								console.log(`GUI Process: ${line}`);
+							}
+						}
+					}
+				}
+			})();
+			
+			// Read stderr
+			(async () => {
+				for await (const chunk of jarProcess.stderr)
+				{
+					console.error(decoder.decode(chunk));
+				}
+			})();
+		}
+		else if(workerData.runtime === "node")
+		{
+			const {spawn} = await import("node:child_process");
+			
+			jarProcess = spawn(
+				JAVA_BIN,
+				_opts,
+				{
+					stdin: "pipe",
+					stdout: "pipe",
+					stderr: "pipe",
+					env: env
+				});
+			
+			jarProcess.stdout.setEncoding("utf8");
+			jarProcess.stderr.setEncoding("utf8");
+			
+			// Receive data from JAVA process
+			jarProcess.stdout.on("data", data => {
+				lineBuffer += data.toString();
+				let i;
+				while((i = lineBuffer.indexOf("\n")) !== -1)
+				{
+					const line = lineBuffer.slice(0, i).trim();
+					lineBuffer = lineBuffer.slice(i + 1);
+					if(line.length > 0)
+					{
+						if(line.startsWith("eyJ")) //line.startsWith("{\"")
+						{
+							handleJarLine(line);
+						}
+						else
+						{
+							console.log(`GUI Process: ${line}`);
+						}
+					}
+				}
+			});
+			
+			jarProcess.stderr.on("data", data => {
+				console.error(data.toString());
+			});
+			
+			jarProcess.on("close", (code) => {
+				console.error(`[jar-worker] GUI exited with code ${code ?? 0}`);
+				jarProcess = null;
+				ready = false;
+				parentPort.postMessage({type: "exit", code: code ?? 0});
+			});
+		}
+		else if(workerData.runtime === "deno")
+		{
+			const command = new Deno.Command(JAVA_BIN, {
+				args: _opts,
+				stdin: "piped",
+				stdout: "piped",
+				stderr: "piped",
+				env: env
+			});
+			
+			jarProcess = command.spawn();
+			stdinWriter = jarProcess.stdin.getWriter();
+			
+			jarProcess.status.then((status) => {
+				console.error(`[jar-worker] GUI exited with code ${status.code}`);
+				jarProcess = null;
+				ready = false;
+				parentPort.postMessage({type: "exit", code: status.code});
+			});
+			
+			// Read stdout
+			(async () => {
+				const reader = jarProcess.stdout.getReader();
+				while(true)
+				{
+					const {done, value} = await reader.read();
+					if(done) break;
+					
+					lineBuffer += decoder.decode(value);
+					let i;
+					while((i = lineBuffer.indexOf("\n")) !== -1)
+					{
+						const line = lineBuffer.slice(0, i).trim();
+						lineBuffer = lineBuffer.slice(i + 1);
+						if(line.length > 0)
+						{
+							if(line.startsWith("eyJ")) //line.startsWith("{\"")
+							{
+								handleJarLine(line);
+							}
+							else
+							{
+								console.log(`GUI Process: ${line}`);
+							}
+						}
+					}
+				}
+			})();
+			
+			// Read stderr
+			(async () => {
+				const reader = jarProcess.stderr.getReader();
+				while(true)
+				{
+					const {done, value} = await reader.read();
+					if(done) break;
+					console.error(decoder.decode(value));
+				}
+			})();
+		}
+	}catch(ex)
+	{
+		console.error(ex);
+	}
+	
+	ready = true;
+}
+
+function sendLineToJar(line)
+{
+	switch(workerData.runtime)
+	{
+		case "deno":
+		{
+			stdinWriter.write(encoder.encode(line));
+			stdinWriter.write(encoder.encode("\n"));
+			break;
+		}
+		default:
+		{
+			jarProcess.stdin.write(line);
+			jarProcess.stdin.write("\n");
+		}
+	}
+}
+
+function handleJarLine(line)
+{
+	if(line.trim().length === 0) return; // ignore empty lines
+
+	line = Buffer.from(line, "base64").toString("utf8");
+
+	// send it as a response if requested
+	if(syncMode && (line.indexOf("\"response\":") > 0 || line.indexOf("%22response%22%3A") > 0)) // check if response JSON object string has response property in it "\"response\":"
+	{
+		responsePort.postMessage(line);
+		syncMode = false;
+		
+		// unblock main thread
+		Atomics.store(sharedBuffSignal, WorkerSignalIndex.ExecutionControl, WorkerSignal.Unblock);
+		Atomics.notify(sharedBuffSignal, WorkerSignalIndex.ExecutionControl);
+	}
+	else
+	{
+		parentPort.postMessage({type: "data", data: line});
+	}
+}
+
+parentPort.on("message", (msg) => {
+	if(!msg) return;
+	
+	if("data" in msg)
+	{
+		// Enter sync mode before writing so no incoming lines are missed
+		if(msg.respond) syncMode = true;
+		sendLineToJar(msg.data);
+	}
+	// Config override: { type: "__config", jarPath?, javaBin?, javaOpts? }
+	else if(msg.type === "__config")
+	{
+		if(msg.jarPath) JAR_PATH = msg.jarPath;
+		if(msg.javaBin) JAVA_BIN = msg.javaBin;
+		if(msg.javaOpts) JAVA_OPTS = msg.javaOpts;
+		console.log(`[jar-worker] Config updated — jar: ${JAR_PATH}`);
+	}
+	// Shutdown: { type: "__shutdown" }
+	else if(msg.type === "__shutdown")
+	{
+		exiting = true;
+		console.log("[jar-worker] Shutdown requested");
+		jarProcess?.kill("SIGTERM");
+	}
+});
+
+await startJar();
+ready = true;
+
+// unblock main thread
+Atomics.store(sharedBuffSignal, WorkerSignalIndex.ExecutionControl, WorkerSignal.Unblock);
+Atomics.notify(sharedBuffSignal, WorkerSignalIndex.ExecutionControl);

package/video-devices-linux.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+
+# Gets video devices and their formats (requires ffmpeg installed)
+
+get_fps() {
+    local dev=$1
+    local res=$2
+    local fmt=$3
+    local fps=""
+
+    if [ "$fmt" = "yuyv422" ]; then
+        stream_line=$(ffmpeg -hide_banner -f v4l2 -video_size "$res" -pix_fmt "$fmt" -i "$dev" -t 1 -y /dev/null 2>&1 | grep "Stream #0:0")
+    else
+        stream_line=$(ffmpeg -hide_banner -f v4l2 -video_size "$res" -codec "$fmt" -i "$dev" -t 1 -y /dev/null 2>&1 | grep "Stream #0:0")
+    fi
+
+    fps=$(echo "$stream_line" | grep -oP ', \K[0-9.]+(?= fps)')
+    echo "$fps"
+}
+
+echo "["
+
+for dev in /dev/video*; do
+    [ -e "$dev" ] || continue
+    dev_id=$(basename "$dev")
+    dev_name=$(cat "/sys/class/video4linux/$dev_id/name")
+    ffmpeg_output=$(ffmpeg -hide_banner -list_formats all -f v4l2 -i "$dev" 2>&1)
+
+    # Include both Raw and Compressed lines
+    format_lines=$(echo "$ffmpeg_output" | grep -E "^\[video4linux2.*(Raw|Compressed)")
+
+    # Remove the [ ... ] part first
+    clean_lines=$(echo "$format_lines" | sed -E 's/\[[^]]*\]//g')
+
+    [ -z "$clean_lines" ] && continue
+
+    echo " {\"id\":\"$dev\",\"name\":\"$dev_name\",\"formats\":["
+
+    while IFS= read -r line; do
+        # Determine if it's Raw or Compressed
+        format_type=""
+        if echo "$line" | grep -q "Raw"; then
+            format_type="raw"
+        elif echo "$line" | grep -q "Compressed"; then
+            format_type="compressed"
+        fi
+
+        # Extract format (2nd field after removing brackets)
+        fmt=$(echo "$line" | cut -d':' -f2 | xargs)
+        # Extract resolutions
+        resolutions=$(echo "$line" | grep -oP '\d+x\d+')
+
+        for res in $resolutions; do
+            fps=$(get_fps "$dev" "$res" "$fmt")
+            [ -z "$fps" ] && fps="?"
+
+            # Output with appropriate prefix based on format type
+            if [ "$format_type" = "raw" ]; then
+                echo "  {\"pixel_format\":\"$fmt\",\"size\":\"$res\",\"min_fps\":$fps,\"max_fps\":$fps},"
+            elif [ "$format_type" = "compressed" ]; then
+                echo "  {\"vcodec\":\"$fmt\",\"size\":\"$res\",\"min_fps\":$fps,\"max_fps\":$fps},"
+            else
+                echo "  {\"format\":\"UNKNOWN\",\"size\":\"$res\",\"min_fps\":$fps,\"max_fps\":$fps},"
+            fi
+        done
+    done <<< "$clean_lines"
+
+    echo "  ]"
+    echo " },"
+done
+
+echo "]"

package/video-devices-mac.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+# Common resolutions to test
+resolutions=("1920x1080" "1280x720" "1024x576" "960x540" "848x480" "640x480" "640x360" "320x240")
+
+# Common framerates to test
+framerates=("60" "30" "24", "15", "10", "5", "3", "2", "1")
+
+echo "Listing macOS video devices..."
+
+# Get device list
+device_list=$(ffmpeg -f avfoundation -list_devices true -i "" 2>&1 | grep "AVFoundation video devices" -A 50 | grep -E "^\[.*\] \[[0-9]+\]" | sed -E 's/.*\[(.*)\] (.*)/\1|\2/')
+
+# Loop through devices
+echo "$device_list" | while IFS="|" read -r id name; do
+    # Skip empty lines
+    [ -z "$id" ] && continue
+    [ -z "$name" ] && continue
+
+    echo "DEVICE|video$id|$name"
+
+    for res in "${resolutions[@]}"; do
+        for fps in "${framerates[@]}"; do
+            # Try ffmpeg capture for 1 second
+            result=$(ffmpeg -f avfoundation -framerate "$fps" -video_size "$res" -i "$id" -t 1 -y /dev/null 2>&1 | grep "Stream #0:0")
+            if [ -n "$result" ]; then
+                echo "RES|avfoundation|$res|$fps"
+            fi
+        done
+    done
+
+    echo "---"
+done

package/CHANGES.md

@@ -1,3 +0,0 @@
-0.1.25
-
-- Preparing for release