Added mouse emulation

remdeskd/.vscode/c_cpp_properties.json

@@ -0,0 +1,18 @@
+{
+  "configurations": [
+    {
+      "name": "windows-gcc-x64",
+      "includePath": [
+        "${workspaceFolder}/**"
+      ],
+      "compilerPath": "C:/TDM-GCC-64/bin/gcc.exe",
+      "cStandard": "${default}",
+      "cppStandard": "${default}",
+      "intelliSenseMode": "windows-gcc-x64",
+      "compilerArgs": [
+        ""
+      ]
+    }
+  ],
+  "version": 4
+}

remdeskd/.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "C/C++ Runner: Debug Session",
+      "type": "cppdbg",
+      "request": "launch",
+      "args": [],
+      "stopAtEntry": false,
+      "externalConsole": true,
+      "cwd": "d:/Invention/RedesKVM/RemdesKVM/usbkvm/usbkvm_fw/src/remdesHid",
+      "program": "d:/Invention/RedesKVM/RemdesKVM/usbkvm/usbkvm_fw/src/remdesHid/build/Debug/outDebug",
+      "MIMode": "gdb",
+      "miDebuggerPath": "gdb",
+      "setupCommands": [
+        {
+          "description": "Enable pretty-printing for gdb",
+          "text": "-enable-pretty-printing",
+          "ignoreFailures": true
+        }
+      ]
+    }
+  ]
+}

remdeskd/.vscode/settings.json

@@ -0,0 +1,59 @@
+{
+  "C_Cpp_Runner.cCompilerPath": "gcc",
+  "C_Cpp_Runner.cppCompilerPath": "g++",
+  "C_Cpp_Runner.debuggerPath": "gdb",
+  "C_Cpp_Runner.cStandard": "",
+  "C_Cpp_Runner.cppStandard": "",
+  "C_Cpp_Runner.msvcBatchPath": "C:/Program Files/Microsoft Visual Studio/VR_NR/Community/VC/Auxiliary/Build/vcvarsall.bat",
+  "C_Cpp_Runner.useMsvc": false,
+  "C_Cpp_Runner.warnings": [
+    "-Wall",
+    "-Wextra",
+    "-Wpedantic",
+    "-Wshadow",
+    "-Wformat=2",
+    "-Wcast-align",
+    "-Wconversion",
+    "-Wsign-conversion",
+    "-Wnull-dereference"
+  ],
+  "C_Cpp_Runner.msvcWarnings": [
+    "/W4",
+    "/permissive-",
+    "/w14242",
+    "/w14287",
+    "/w14296",
+    "/w14311",
+    "/w14826",
+    "/w44062",
+    "/w44242",
+    "/w14905",
+    "/w14906",
+    "/w14263",
+    "/w44265",
+    "/w14928"
+  ],
+  "C_Cpp_Runner.enableWarnings": true,
+  "C_Cpp_Runner.warningsAsError": false,
+  "C_Cpp_Runner.compilerArgs": [],
+  "C_Cpp_Runner.linkerArgs": [],
+  "C_Cpp_Runner.includePaths": [],
+  "C_Cpp_Runner.includeSearch": [
+    "*",
+    "**/*"
+  ],
+  "C_Cpp_Runner.excludeSearch": [
+    "**/build",
+    "**/build/**",
+    "**/.*",
+    "**/.*/**",
+    "**/.vscode",
+    "**/.vscode/**"
+  ],
+  "C_Cpp_Runner.useAddressSanitizer": false,
+  "C_Cpp_Runner.useUndefinedSanitizer": false,
+  "C_Cpp_Runner.useLeakSanitizer": false,
+  "C_Cpp_Runner.showCompilationTime": false,
+  "C_Cpp_Runner.useLinkTimeOptimization": false,
+  "C_Cpp_Runner.msvcSecureNoWarnings": false
+}

remdeskd/go.mod

@@ -2,11 +2,14 @@ module imuslab.com/remdeskvm/remdeskd
 
 go 1.23.4
 
-require github.com/vladimirvivien/go4vl v0.0.5
+require (
+	github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07
+	github.com/vladimirvivien/go4vl v0.0.5
+	golang.org/x/crypto v0.36.0
+)
 
 require (
-	github.com/gen2brain/x264-go v0.3.1 // indirect
-	github.com/gen2brain/x264-go/x264c v0.0.0-20241022182000-732e1bdb7da2 // indirect
-	github.com/gen2brain/x264-go/yuv v0.0.0-20241022182000-732e1bdb7da2 // indirect
-	golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c // indirect
+	golang.org/x/net v0.21.0 // indirect
+	golang.org/x/sys v0.31.0 // indirect
+	golang.org/x/text v0.23.0 // indirect
 )

remdeskd/go.sum

@@ -1,10 +1,13 @@
-github.com/gen2brain/x264-go v0.3.1 h1:XFi6y8HM5BCMrP4kR/o711iBU++XNfLOY3PG8Alz2kU=
-github.com/gen2brain/x264-go v0.3.1/go.mod h1:+Z4VKXQrUKzbfEv36GyiyjXfixmOp2c820ugsMthW18=
-github.com/gen2brain/x264-go/x264c v0.0.0-20241022182000-732e1bdb7da2 h1:aS40m/Q+6z0ID7EVegxnnw3lWHUceGbg0zucbo7335I=
-github.com/gen2brain/x264-go/x264c v0.0.0-20241022182000-732e1bdb7da2/go.mod h1:r2t0/BO5YgPRwWQpLYO5iB5FLSj1ArTQc/zmAoAV7sQ=
-github.com/gen2brain/x264-go/yuv v0.0.0-20241022182000-732e1bdb7da2 h1:bqM055OxaqM/IPFGU84u0ROJW2wvvC3KGEAQuT+3WBs=
-github.com/gen2brain/x264-go/yuv v0.0.0-20241022182000-732e1bdb7da2/go.mod h1:tVJ40WrnqgDLb+itPvllvybW0/3jz5BzUFrEHvYIoGU=
+github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07 h1:UyzmZLoiDWMRywV4DUYb9Fbt8uiOSooupjTq10vpvnU=
+github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
 github.com/vladimirvivien/go4vl v0.0.5 h1:jHuo/CZOAzYGzrSMOc7anOMNDr03uWH5c1B5kQ+Chnc=
 github.com/vladimirvivien/go4vl v0.0.5/go.mod h1:FP+/fG/X1DUdbZl9uN+l33vId1QneVn+W80JMc17OL8=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=

remdeskd/main.go

@@ -1,171 +1,37 @@
 package main
 
 import (
-	"context"
-	"errors"
-	"fmt"
+	"embed"
+	"io/fs"
 	"log"
-	"mime/multipart"
 	"net/http"
-	"net/textproto"
-	"strings"
-	"syscall"
-
-	"github.com/vladimirvivien/go4vl/device"
-	"github.com/vladimirvivien/go4vl/v4l2"
 )
 
-var (
-	camera *device.Device
-	frames <-chan []byte
-	fps    uint32 = 30
-	/*
-		1920 x 1080 60fps = 55Mbps //Edge not support
-		1920 x 1080 30fps = 50Mbps
-		1920 x 1080 25fps = 40Mbps
-		1920 x 1080 20fps = 30Mbps
-		1920 x 1080 10fps = 15Mbps
-
-		1360 x 768 60fps = 28Mbps
-		1360 x 768 30fps = 25Mbps
-		1360 x 768 25fps = 20Mbps
-		1360 x 768 20fps = 18Mbps
-		1360 x 768 10fps = 10Mbps
-	*/
-	pixfmt     v4l2.FourCCType
-	width      = 1920
-	height     = 1080
-	streamInfo string
-)
+const development = true
 
-// start http service
-func serveVideoStream(w http.ResponseWriter, req *http.Request) {
-	mimeWriter := multipart.NewWriter(w)
-	w.Header().Set("Content-Type", fmt.Sprintf("multipart/x-mixed-replace; boundary=%s", mimeWriter.Boundary()))
-	partHeader := make(textproto.MIMEHeader)
-	partHeader.Add("Content-Type", "image/jpeg")
+//go:embed www
+var embeddedFiles embed.FS
+var webfs http.FileSystem
 
-	var frame []byte
-	for frame = range frames {
-		if len(frame) == 0 {
-			log.Print("skipping empty frame")
-			continue
-		}
-
-		partWriter, err := mimeWriter.CreatePart(partHeader)
+func init() {
+	if development {
+		webfs = http.Dir("./www")
+	} else {
+		// Embed the ./www folder and trim the prefix
+		subFS, err := fs.Sub(embeddedFiles, "www")
 		if err != nil {
-			log.Printf("failed to create multi-part writer: %s", err)
-			return
-		}
-
-		if _, err := partWriter.Write(frame); err != nil {
-			if errors.Is(err, syscall.EPIPE) {
-				//broken pipe, the client browser has exited
-				return
-			}
-			log.Printf("failed to write image: %s", err)
+			log.Fatal(err)
 		}
-
+		webfs = http.FS(subFS)
 	}
 }
 
 func main() {
-	port := ":9090"
-	devName := "/dev/video0"
-	frameRate := int(fps)
-	buffSize := 8
-	format := "mjpeg"
-
-	//Check if the video device is a capture device
-	isCaptureDev, err := checkVideoCaptureDevice(devName)
-	if err != nil {
-		panic(err)
-	}
-	if !isCaptureDev {
-		panic("target device is not a capture-able device")
-	}
-	camera, err := device.Open(devName,
-		device.WithIOType(v4l2.IOTypeMMAP),
-		device.WithPixFormat(v4l2.PixFormat{PixelFormat: getFormatType(format), Width: uint32(width), Height: uint32(height), Field: v4l2.FieldAny}),
-		device.WithFPS(uint32(frameRate)),
-		device.WithBufferSize(uint32(buffSize)),
-	)
-
-	if err != nil {
-		log.Fatalf("failed to open device: %s", err)
-	}
-	defer camera.Close()
+	http.Handle("/", http.FileServer(webfs))
 
-	//Get video supported sizes
-	formatInfo, err := getV4L2FormatInfo(devName)
-	if err != nil {
-		log.Fatal(err)
-	}
-	for _, format := range formatInfo {
-		fmt.Printf("Format: %s\n", format.Format)
-		for _, size := range format.Sizes {
-			fmt.Printf("  Size: %dx%d\n", size.Width, size.Height)
-			fmt.Printf("    FPS: %v\n", size.FPS)
-		}
-	}
-
-	caps := camera.Capability()
-	log.Printf("device [%s] opened\n", devName)
-	log.Printf("device info: %s", caps.String())
-	//2025/03/16 15:45:25 device info: driver: uvcvideo; card: USB Video: USB Video; bus info: usb-0000:00:14.0-2
+	addr := ":8080"
 
-	// set device format
-	currFmt, err := camera.GetPixFormat()
-	if err != nil {
-		log.Fatalf("unable to get format: %s", err)
-	}
-	log.Printf("Current format: %s", currFmt)
-	//2025/03/16 15:45:25 Current format: Motion-JPEG [1920x1080]; field=any; bytes per line=0; size image=0; colorspace=Default; YCbCr=Default; Quant=Default; XferFunc=Default
-	pixfmt = currFmt.PixelFormat
-	streamInfo = fmt.Sprintf("%s - %s [%dx%d] %d fps",
-		caps.Card,
-		v4l2.PixelFormats[currFmt.PixelFormat],
-		currFmt.Width, currFmt.Height, frameRate,
-	)
-
-	// start capture
-	ctx, cancel := context.WithCancel(context.TODO())
-	if err := camera.Start(ctx); err != nil {
-		log.Fatalf("stream capture: %s", err)
-	}
-	defer func() {
-		cancel()
-		camera.Close()
-	}()
+	log.Printf("Serving on http://localhost%s\n", addr)
+	log.Fatal(http.ListenAndServe(addr, nil))
 
-	// video stream
-	frames = camera.GetOutput()
-
-	log.Printf("device capture started (buffer size set %d)", camera.BufferCount())
-	log.Printf("starting server on port %s", port)
-	log.Println("use url path /webcam")
-
-	// setup http service
-	http.HandleFunc("/stream", serveVideoStream) // returns video feed
-	if err := http.ListenAndServe(port, nil); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func getFormatType(fmtStr string) v4l2.FourCCType {
-	switch strings.ToLower(fmtStr) {
-	case "jpeg":
-		return v4l2.PixelFmtJPEG
-	case "mpeg":
-		return v4l2.PixelFmtMPEG
-	case "mjpeg":
-		return v4l2.PixelFmtMJPEG
-	case "h264", "h.264":
-		return v4l2.PixelFmtH264
-	case "yuyv":
-		return v4l2.PixelFmtYUYV
-	case "rgb":
-		return v4l2.PixelFmtRGB24
-	}
-	return v4l2.PixelFmtMPEG
 }

remdeskd/mod/remdeshid/remdeshid.go

@@ -0,0 +1,102 @@
+package remdeshid
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/tarm/serial"
+)
+
+type Config struct {
+	/* Bindings and callback */
+	OnWriteError  func(error)         // Callback for when an error occurs while writing to USBKVM device
+	OnReadError   func(error)         // Callback for when an error occurs while reading from USBKVM device
+	OnDataHandler func([]byte, error) // Callback for when data is received from USBKVM device
+
+	/* Serial port configs */
+	PortName string
+	BaudRate int
+}
+
+// HIDController is a struct that represents a HID controller
+type HIDController struct {
+	Config        *Config
+	serialPort    *serial.Port
+	serialRunning bool
+	stopChan      chan bool
+}
+
+func NewHIDController(config *Config) *HIDController {
+	return &HIDController{
+		Config:        config,
+		serialRunning: false,
+	}
+}
+
+// Connect opens the serial port and starts reading from it
+func (c *HIDController) Connect() error {
+
+	// Open the serial port
+	config := &serial.Config{
+		Name:   c.Config.PortName,
+		Baud:   c.Config.BaudRate,
+		Size:   8,
+		Parity: serial.ParityNone,
+	}
+
+	port, err := serial.OpenPort(config)
+	if err != nil {
+		return err
+	}
+
+	c.serialPort = port
+
+	//Start reading from the serial port
+	go func() {
+		buf := make([]byte, 128)
+		for {
+			n, err := port.Read(buf)
+			if err != nil {
+				if c.Config.OnReadError != nil {
+					c.Config.OnReadError(err)
+				} else {
+					log.Println(err.Error())
+				}
+				return
+			}
+			if n > 0 {
+				if c.Config.OnDataHandler != nil {
+					c.Config.OnDataHandler(buf[:n], nil)
+				} else {
+					fmt.Print("Received bytes: ")
+					for i := 0; i < n; i++ {
+						fmt.Printf("0x%02X ", buf[i])
+					}
+					fmt.Println()
+				}
+
+			}
+		}
+	}()
+	return nil
+}
+
+func (c *HIDController) Send(data []byte) error {
+	n, err := c.serialPort.Write(data)
+	if err != nil {
+		return err
+	}
+	if n != len(data) {
+		return fmt.Errorf("Failed to write all bytes to serial port")
+	}
+	time.Sleep(10 * time.Millisecond) //Minimum delay between writes
+	return nil
+}
+
+func (c *HIDController) Close() {
+	if c.stopChan != nil {
+		c.stopChan <- true
+	}
+	c.serialPort.Close()
+}

remdeskd/mod/remdeshid/typedef.go

@@ -0,0 +1,47 @@
+package remdeshid
+
+// Operation Types
+const (
+	OPR_TYPE_RESERVED          = 0x00
+	OPR_TYPE_KEYBOARD_WRITE    = 0x01
+	OPR_TYPE_MOUSE_WRITE       = 0x02
+	OPR_TYPE_SWITCH_WRITE      = 0x03
+	OPR_TYPE_LED_WRITE         = 0x04
+	OPR_TYPE_RESET_INSTR_COUNT = 0xFE
+	OPR_TYPE_DATA_RESET        = 0xFF
+)
+
+// Operation Sub-types
+const (
+	SUBTYPE_RESERVED = 0x00
+)
+
+// Keyboard Subtypes
+const (
+	SUBTYPE_KEYBOARD_ASCII_WRITE        = 0x01
+	SUBTYPE_KEYBOARD_ASCII_PRESS        = 0x02
+	SUBTYPE_KEYBOARD_ASCII_RELEASE      = 0x03
+	SUBTYPE_KEYBOARD_MODIFIER_SET       = 0x04
+	SUBTYPE_KEYBOARD_MODIFIER_CLEAR     = 0x05
+	SUBTYPE_KEYBOARD_FUNCTKEY_WRITE     = 0x06
+	SUBTYPE_KEYBOARD_OTHERKEY_PRESS     = 0x07
+	SUBTYPE_KEYBOARD_OTHERKEY_RELEASE   = 0x08
+	SUBTYPE_KEYBOARD_SPECIAL_CTRLALTDEL = 0xFD
+	SUBTYPE_KEYBOARD_SPECIAL_RESET      = 0xFE
+	SUBTYPE_KEYBOARD_SPECIAL_RESERVED   = 0xFF
+)
+
+// Response Codes
+const (
+	RESP_OK                = 0x00
+	RESP_UNKNOWN_OPR       = 0x01
+	RESP_INVALID_OPR_TYPE  = 0x02
+	RESP_INVALID_KEY_VALUE = 0x03
+	RESP_NOT_IMPLEMENTED   = 0x04
+
+	RESP_START_OF_DEBUG_MSG = 0xE0
+	RESP_END_OF_DEBUG_MSG   = 0xE1
+
+	RESP_START_OF_ERR_MSG = 0xEE
+	RESP_END_OF_ERR_MSG   = 0xEF
+)

remdeskd/mod/usbcapture/usbcapture.go

@@ -0,0 +1,172 @@
+package usbcapture
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"mime/multipart"
+	"net/http"
+	"net/textproto"
+	"strings"
+	"syscall"
+
+	"github.com/vladimirvivien/go4vl/device"
+	"github.com/vladimirvivien/go4vl/v4l2"
+)
+
+var (
+	camera *device.Device
+	frames <-chan []byte
+	fps    uint32 = 30
+	/*
+		1920 x 1080 60fps = 55Mbps //Edge not support
+		1920 x 1080 30fps = 50Mbps
+		1920 x 1080 25fps = 40Mbps
+		1920 x 1080 20fps = 30Mbps
+		1920 x 1080 10fps = 15Mbps
+
+		1360 x 768 60fps = 28Mbps
+		1360 x 768 30fps = 25Mbps
+		1360 x 768 25fps = 20Mbps
+		1360 x 768 20fps = 18Mbps
+		1360 x 768 10fps = 10Mbps
+	*/
+	pixfmt     v4l2.FourCCType
+	width      = 1920
+	height     = 1080
+	streamInfo string
+)
+
+// start http service
+func serveVideoStream(w http.ResponseWriter, req *http.Request) {
+	mimeWriter := multipart.NewWriter(w)
+	w.Header().Set("Content-Type", fmt.Sprintf("multipart/x-mixed-replace; boundary=%s", mimeWriter.Boundary()))
+	partHeader := make(textproto.MIMEHeader)
+	partHeader.Add("Content-Type", "image/jpeg")
+
+	var frame []byte
+	for frame = range frames {
+		if len(frame) == 0 {
+			log.Print("skipping empty frame")
+			continue
+		}
+
+		partWriter, err := mimeWriter.CreatePart(partHeader)
+		if err != nil {
+			log.Printf("failed to create multi-part writer: %s", err)
+			return
+		}
+
+		if _, err := partWriter.Write(frame); err != nil {
+			if errors.Is(err, syscall.EPIPE) {
+				//broken pipe, the client browser has exited
+				return
+			}
+			log.Printf("failed to write image: %s", err)
+		}
+
+	}
+}
+
+// startVideoServer starts the video server
+func startVideoServer() {
+	port := ":9090"
+	devName := "/dev/video0"
+	frameRate := int(fps)
+	buffSize := 8
+	format := "mjpeg"
+
+	//Check if the video device is a capture device
+	isCaptureDev, err := checkVideoCaptureDevice(devName)
+	if err != nil {
+		panic(err)
+	}
+	if !isCaptureDev {
+		panic("target device is not a capture-able device")
+	}
+	camera, err := device.Open(devName,
+		device.WithIOType(v4l2.IOTypeMMAP),
+		device.WithPixFormat(v4l2.PixFormat{PixelFormat: getFormatType(format), Width: uint32(width), Height: uint32(height), Field: v4l2.FieldAny}),
+		device.WithFPS(uint32(frameRate)),
+		device.WithBufferSize(uint32(buffSize)),
+	)
+
+	if err != nil {
+		log.Fatalf("failed to open device: %s", err)
+	}
+	defer camera.Close()
+
+	//Get video supported sizes
+	formatInfo, err := getV4L2FormatInfo(devName)
+	if err != nil {
+		log.Fatal(err)
+	}
+	for _, format := range formatInfo {
+		fmt.Printf("Format: %s\n", format.Format)
+		for _, size := range format.Sizes {
+			fmt.Printf("  Size: %dx%d\n", size.Width, size.Height)
+			fmt.Printf("    FPS: %v\n", size.FPS)
+		}
+	}
+
+	caps := camera.Capability()
+	log.Printf("device [%s] opened\n", devName)
+	log.Printf("device info: %s", caps.String())
+	//2025/03/16 15:45:25 device info: driver: uvcvideo; card: USB Video: USB Video; bus info: usb-0000:00:14.0-2
+
+	// set device format
+	currFmt, err := camera.GetPixFormat()
+	if err != nil {
+		log.Fatalf("unable to get format: %s", err)
+	}
+	log.Printf("Current format: %s", currFmt)
+	//2025/03/16 15:45:25 Current format: Motion-JPEG [1920x1080]; field=any; bytes per line=0; size image=0; colorspace=Default; YCbCr=Default; Quant=Default; XferFunc=Default
+	pixfmt = currFmt.PixelFormat
+	streamInfo = fmt.Sprintf("%s - %s [%dx%d] %d fps",
+		caps.Card,
+		v4l2.PixelFormats[currFmt.PixelFormat],
+		currFmt.Width, currFmt.Height, frameRate,
+	)
+
+	// start capture
+	ctx, cancel := context.WithCancel(context.TODO())
+	if err := camera.Start(ctx); err != nil {
+		log.Fatalf("stream capture: %s", err)
+	}
+	defer func() {
+		cancel()
+		camera.Close()
+	}()
+
+	// video stream
+	frames = camera.GetOutput()
+
+	log.Printf("device capture started (buffer size set %d)", camera.BufferCount())
+	log.Printf("starting server on port %s", port)
+	log.Println("use url path /webcam")
+
+	// setup http service
+	http.HandleFunc("/stream", serveVideoStream) // returns video feed
+	if err := http.ListenAndServe(port, nil); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func getFormatType(fmtStr string) v4l2.FourCCType {
+	switch strings.ToLower(fmtStr) {
+	case "jpeg":
+		return v4l2.PixelFmtJPEG
+	case "mpeg":
+		return v4l2.PixelFmtMPEG
+	case "mjpeg":
+		return v4l2.PixelFmtMJPEG
+	case "h264", "h.264":
+		return v4l2.PixelFmtH264
+	case "yuyv":
+		return v4l2.PixelFmtYUYV
+	case "rgb":
+		return v4l2.PixelFmtRGB24
+	}
+	return v4l2.PixelFmtMPEG
+}

remdeskd/video_device.go → remdeskd/mod/usbcapture/video_device.go

@@ -1,4 +1,4 @@
-package main
+package usbcapture
 
 import (
 	"bufio"

remdeskd/www/index.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description" content="A basic Hello World HTML page with metadata and OpenGraph headers">
+    <meta name="author" content="Your Name">
+    <title>Hello World</title>
+    
+    <!-- OpenGraph Metadata -->
+    <meta property="og:title" content="Hello World">
+    <meta property="og:description" content="A basic Hello World HTML page with metadata and OpenGraph headers">
+    <meta property="og:type" content="website">
+    <meta property="og:url" content="http://example.com">
+    <meta property="og:image" content="http://example.com/image.jpg">
+</head>
+<body>
+    <h1>Hello World</h1>
+    <p>Welcome to my website!</p>
+</body>
+</html>

usbkvm/debug_terminal/mouse_click.bat

@@ -0,0 +1,11 @@
+@echo off
+:: Hold the left mouse button for 3 seconds
+.\send.exe COM4 115200 0x02 0x02 0x01
+timeout /t 3 /nobreak >nul
+.\send.exe COM4 115200 0x02 0x03 0x01
+timeout /t 3 /nobreak >nul
+:: Do a right click
+.\send.exe COM4 115200 0x02 0x01 0x02
+timeout /t 3 /nobreak >nul
+:: Do a middle click
+.\send.exe COM4 115200 0x02 0x01 0x03

usbkvm/debug_terminal/mouse_home.bat

@@ -0,0 +1,15 @@
+@echo off
+:: Move cursor to the top left corner
+.\send.exe COM4 115200 0x02 0x04 0x00
+timeout /t 3 /nobreak >nul
+
+:: Move cursor to the bottom left corner
+.\send.exe COM4 115200 0x02 0x04 0x01
+timeout /t 3 /nobreak >nul
+
+:: Move cursor to the top left corner
+.\send.exe COM4 115200 0x02 0x04 0x02
+timeout /t 3 /nobreak >nul
+
+:: Move cursor to the bottom right corner
+.\send.exe COM4 115200 0x02 0x04 0x03

usbkvm/debug_terminal/mouse_move.bat

@@ -0,0 +1,12 @@
+@echo off
+:: Move up
+.\send.exe COM4 115200 0x03 0x00 0x80 0x00 0x00
+timeout /t 1 /nobreak >nul
+:: Move down
+.\send.exe COM4 115200 0x03 0x00 0x80 0x00 0x01
+timeout /t 1 /nobreak >nul
+:: Move right
+.\send.exe COM4 115200 0x03 0x80 0x00 0x00 0x00
+timeout /t 1 /nobreak >nul
+:: Move left
+.\send.exe COM4 115200 0x03 0x80 0x00 0x01 0x00

usbkvm/debug_terminal/mouse_scroll.bat

@@ -0,0 +1,6 @@
+@echo off
+:: Scroll down 
+.\send.exe COM4 115200 0x04 0x00 0x02
+timeout /t 3 /nobreak >nul
+:: Scroll up
+.\send.exe COM4 115200 0x04 0x01 0x02

usbkvm/usbkvm_fw/keyboard_emu.ino

@@ -178,9 +178,7 @@ uint8_t keyboard_emulation(uint8_t subtype, uint8_t value) {
     case SUBTYPE_KEYBOARD_FUNCTKEY_WRITE:
       if (!is_funckey(value))
         return resp_invalid_key_value;
-      Keyboard_press(value);
-      delay(100);
-      Keyboard_release(value);
+      Keyboard_write(value);
       return resp_ok;
     case SUBTYPE_KEYBOARD_OTHERKEY_PRESS:
       if (!is_validkeys(value))
@@ -201,13 +199,14 @@ uint8_t keyboard_emulation(uint8_t subtype, uint8_t value) {
 
       // Release Ctrl + Alt + Del in reverse order
       Keyboard_release(KEY_DELETE);
-      delay(20);
+      delay(MIN_KEY_EVENTS_DELAY);
       Keyboard_release(KEY_LEFT_ALT);
-      delay(20);
+      delay(MIN_KEY_EVENTS_DELAY);
       Keyboard_release(KEY_LEFT_CTRL);
-      delay(20);
+      delay(MIN_KEY_EVENTS_DELAY);
       return resp_ok;
     case SUBTYPE_KEYBOARD_SPECIAL_RESET:
+      //Release all pressed keys
       Keyboard_releaseAll();
       return resp_ok;
     default:

usbkvm/usbkvm_fw/mouse_emu.ino

@@ -0,0 +1,150 @@
+/*
+  mouse_emu.ino
+  Author: tobychui
+
+  This code file handle keyboard emulation related functionality
+  When opr_type is set to 0x02, the sub-handler will process the
+  request here.
+
+ -- Mouse Opcode --
+  0x00 = Reserved
+  0x01 = Mouse Click
+  0x02 = Mouse Press
+  0x03 = Mouse Release
+    0x00 = Left Button 
+    0x01 = Right Button
+    0x02 = Middle button
+  0x04 = Mouse Position Presets
+    0x00 = [0,0] (top left)
+    0x01 = [0, max] (bottom left)
+    0x02 = [max, 0] (top right)
+    0x03 = [max, max] (bottom right)
+  0x05 = Release All Mouse Buttons
+*/
+
+#include "usbkvm_fw.h"
+//#define ENABLE_MOUSE_DEBUG
+
+//Move cursor back to [0,0] position
+void reset_cursor_to_home() {
+  for (int i = 0; i < 16; i++) {
+    //16 loops should be able to home a mouse to [0,0] from a 4k display
+    Mouse_move(-1 * (int8_t)127, -1 * (int8_t)127);
+  }
+}
+
+//Move the cursor to target position, with multiplier of 10x
+void move_cursor_to_pos(uint8_t x, uint8_t y) {
+  for (int i = 0; i < 10; i++) {
+    Mouse_move((int8_t)x, (int8_t)y);
+  }
+}
+//Handle mouse move, x, y, and direction of x, y (positive: 0x00, negative 0x01)
+uint8_t mouse_move(uint8_t ux, uint8_t uy, uint8_t dx, uint8_t dy) {
+  if (ux > 0x7F) ux = 0x7F;
+  if (uy > 0x7F) uy = 0x7F;
+
+  int8_t x = ux;
+  int8_t y = uy;
+  if (dx == 0x01)
+    x = -x;
+  if (dy == 0x01)
+    y = -y;
+#ifdef ENABLE_MOUSE_DEBUG
+  Serial0_write(resp_start_of_info_msg);
+  Serial0_write(ux);
+  Serial0_write(uy);
+  Serial0_write(resp_end_of_msg);
+#endif
+  Mouse_move(x, y);
+  return resp_ok;
+}
+
+//Handle mouse move, direction accept 0x00 (down / right) or 0x01 (up / left)
+uint8_t mouse_scroll(uint8_t direction, uint8_t utilt) {
+  int8_t tilt;
+  if (direction == 0x01) {
+    //Down
+    if (utilt >= 0x7F) {
+      tilt = -127;
+    } else {
+      tilt = (int8_t)utilt * -1;
+    }
+  } else {
+    //Up
+    if (utilt >= 0x7F) {
+      tilt = 127;
+    } else {
+      tilt = (int8_t)utilt;
+    }
+  }
+#ifdef ENABLE_MOUSE_DEBUG
+  Serial0_write(resp_start_of_info_msg);
+  Serial0_write(tilt);
+  Serial0_write(resp_end_of_msg);
+#endif
+  Mouse_scroll(tilt);
+  delay(MIN_KEY_EVENTS_DELAY);
+  return resp_ok;
+}
+
+uint8_t mouse_emulation(uint8_t subtype, uint8_t value) {
+  switch (subtype) {
+    case SUBTYPE_MOUSE_CLICK:
+      if (value == PAYLOAD_MOUSE_BTN_LEFT) {
+        Mouse_click(MOUSE_LEFT);
+      } else if (value == PAYLOAD_MOUSE_BTN_RIGHT) {
+        Mouse_click(MOUSE_RIGHT);
+      } else if (value == PAYLOAD_MOUSE_BTN_MID) {
+        Mouse_click(MOUSE_MIDDLE);
+      } else {
+        return resp_invalid_key_value;
+      }
+      return resp_ok;
+    case SUBTYPE_MOUSE_PRESS:
+      if (value == PAYLOAD_MOUSE_BTN_LEFT) {
+        Mouse_press(MOUSE_LEFT);
+      } else if (value == PAYLOAD_MOUSE_BTN_RIGHT) {
+        Mouse_press(MOUSE_RIGHT);
+      } else if (value == PAYLOAD_MOUSE_BTN_MID) {
+        Mouse_press(MOUSE_MIDDLE);
+      } else {
+        return resp_invalid_key_value;
+      }
+      return resp_ok;
+    case SUBTYPE_MOUSE_RELEASE:
+      if (value == PAYLOAD_MOUSE_BTN_LEFT) {
+        Mouse_release(MOUSE_LEFT);
+      } else if (value == PAYLOAD_MOUSE_BTN_RIGHT) {
+        Mouse_release(MOUSE_RIGHT);
+      } else if (value == PAYLOAD_MOUSE_BTN_MID) {
+        Mouse_release(MOUSE_MIDDLE);
+      } else {
+        return resp_invalid_key_value;
+      }
+      return resp_ok;
+    case SUBTYPE_MOUSE_SETPOS:
+      if (value == 0x00) {
+        reset_cursor_to_home();
+      } else if (value == 0x01) {
+        reset_cursor_to_home();
+        move_cursor_to_pos(0, 127);
+      } else if (value == 0x02) {
+        reset_cursor_to_home();
+        move_cursor_to_pos(127, 0);
+      } else if (value == 0x03) {
+        reset_cursor_to_home();
+        move_cursor_to_pos(127, 127);
+      } else {
+        return resp_invalid_key_value;
+      }
+    case SUBTYPE_MOUSE_RESET:
+      Mouse_release(MOUSE_LEFT);
+      Mouse_release(MOUSE_RIGHT);
+      Mouse_release(MOUSE_MIDDLE);
+      delay(MIN_KEY_EVENTS_DELAY);
+    default:
+      return resp_invalid_opr_type;
+  }
+  return resp_invalid_opr_type;
+}

usbkvm/usbkvm_fw/usbkvm_fw.h

@@ -7,6 +7,7 @@
 #define _usbkvm_
 
 /* Hardware Configurations */
+#define MIN_KEY_EVENTS_DELAY 20  //ms
 #define LED_RW_SIG 16
 #define USB_SW_SEL 32
 
@@ -14,8 +15,10 @@
 #define OPR_TYPE_RESERVED 0x00           // Reserved
 #define OPR_TYPE_KEYBOARD_WRITE 0x01     // Keyboard-related operation
 #define OPR_TYPE_MOUSE_WRITE 0x02        // Mouse-related operation
-#define OPR_TYPE_SWITCH_WRITE 0x03       // Switch/button operation
-#define OPR_TYPE_LED_WRITE 0x04          // LED control operation
+#define OPR_TYPE_MOUSE_MOVE 0x03         // Mouse-move operation (Notes: When opr_type is OPR_TYPE_MOUSE_MOVE, opr_subtype is the X position value)
+#define OPR_TYPE_MOUSE_SCROLL 0x04       //Mouse scroll (Notes: when opr_type is OPR_TYPE_MOUSE_SCROLL, opr_subtype is up/down and payload is scroll tilt valie (max 127))
+#define OPR_TYPE_SWITCH_WRITE 0x05       // Switch/button operation
+#define OPR_TYPE_LED_WRITE 0x06          // LED control operation
 #define OPR_TYPE_RESET_INSTR_COUNT 0xFE  // Reset instruction counter
 #define OPR_TYPE_DATA_RESET 0xFF         //Reset opr data queue, if state of device is unknown, clear before use
 
@@ -26,7 +29,7 @@
 #define SUBTYPE_KEYBOARD_ASCII_WRITE 0x01         // Write ASCII characters (32-127)
 #define SUBTYPE_KEYBOARD_ASCII_PRESS 0x02         // Press a key (ASCII 32-127)
 #define SUBTYPE_KEYBOARD_ASCII_RELEASE 0x03       // Release a key (ASCII 32-127)
-#define SUBTYPE_KEYBOARD_MODIFIER_SET 0x04      // Modifier key write (bit flags)
+#define SUBTYPE_KEYBOARD_MODIFIER_SET 0x04        // Modifier key write (bit flags)
 #define SUBTYPE_KEYBOARD_MODIFIER_CLEAR 0x05      // Modifier key press (bit flags)
 #define SUBTYPE_KEYBOARD_FUNCTKEY_WRITE 0x06      //Function key write
 #define SUBTYPE_KEYBOARD_OTHERKEY_PRESS 0x07      //Other keys press
@@ -35,6 +38,18 @@
 #define SUBTYPE_KEYBOARD_SPECIAL_RESET 0xFE       //Reset all keypress state
 #define SUBTYPE_KEYBOARD_SPECIAL_RESERVED 0xFF    //Reserved
 
+/* Mouse Subtypes */
+#define SUBTYPE_MOUSE_CLICK 0x01    //Mouse button click
+#define SUBTYPE_MOUSE_PRESS 0x02    //Mouse button press
+#define SUBTYPE_MOUSE_RELEASE 0x03  //Mouse button release
+#define SUBTYPE_MOUSE_SETPOS 0x04   //Mouse presets position
+#define SUBTYPE_MOUSE_RESET 0x05    //Reset all mouse button states
+
+/* Mouse Buttons ID */
+#define PAYLOAD_MOUSE_BTN_LEFT 0x01
+#define PAYLOAD_MOUSE_BTN_RIGHT 0x02
+#define PAYLOAD_MOUSE_BTN_MID 0x03
+
 /* Response Codes */
 #define resp_ok 0x00
 #define resp_unknown_opr 0x01
@@ -42,10 +57,7 @@
 #define resp_invalid_key_value 0x03
 #define resp_not_implemented 0x04
 
-
-#define resp_start_of_debug_msg 0xE0
-#define resp_end_of_debug_msg 0xE1
-
-#define resp_start_of_err_msg 0xEE
-#define resp_end_of_err_msg 0xEF
+/* Debug */
+#define resp_start_of_info_msg 0xED
+#define resp_end_of_msg 0xEF
 #endif

usbkvm/usbkvm_fw/usbkvm_fw.ino

@@ -46,12 +46,21 @@ uint8_t opr_type = 0x00;
 uint8_t opr_subtype = 0x00;
 uint8_t opr_payload = 0x00;
 
+/*
+  cursor_direction_data handles special subtype data
+  that requires to move the cursor position
+*/
+uint8_t cursor_direction_data[2] = { 0x00, 0x00 };
+
 uint8_t serial_data = 0x00;
 
 /* Function Prototypes */
 uint8_t keyboard_emulation(uint8_t, uint8_t);
+uint8_t mouse_emulation(uint8_t, uint8_t);
+uint8_t mouse_move(uint8_t, uint8_t, uint8_t, uint8_t);
+uint8_t mouse_scroll(uint8_t, uint8_t);
 
-
+/* KVM Operation Execution Catergory*/
 uint8_t kvm_execute_opr() {
   switch (opr_type) {
     case OPR_TYPE_RESERVED:
@@ -62,7 +71,11 @@ uint8_t kvm_execute_opr() {
       return keyboard_emulation(opr_subtype, opr_payload);
     case OPR_TYPE_MOUSE_WRITE:
       //mouse operations
-      return resp_ok;
+      return mouse_emulation(opr_subtype, opr_payload);
+    case OPR_TYPE_MOUSE_SCROLL:
+      //mouse scroll
+      //for larger scroll tilt value, use the multipler
+      return mouse_scroll(opr_subtype, opr_payload);
     default:
       return resp_unknown_opr;
   }
@@ -85,15 +98,15 @@ void loop() {
 
 #ifdef ENABLE_DEBUG_PRINT
     //Debug print the Serial input message
-    Serial0_write(resp_start_of_debug_msg);
+    Serial0_write(resp_start_of_info_msg);
     Serial0_write(serial_data);
-    Serial0_write(resp_end_of_debug_msg);
+    Serial0_write(resp_end_of_msg);
 #endif
 
     if (serial_data == OPR_TYPE_DATA_RESET) {
       //Reset opr data
-      opr_type = 0x00;
-      opr_subtype = 0x00;
+      opr_type = OPR_TYPE_RESERVED;
+      opr_subtype = SUBTYPE_RESERVED;
       opr_payload = 0x00;
       instr_count = 0;
       Serial0_write(resp_ok);
@@ -107,28 +120,25 @@ void loop() {
       opr_subtype = serial_data;
       instr_count++;
       Serial0_write(resp_ok);
+    } else if (opr_type == OPR_TYPE_MOUSE_MOVE) {
+      //Special case where mouse move requires 4 opcodes
+      if (instr_count == 2) {
+        opr_payload = serial_data; //y-steps, reusing payload for lower memory consumption
+        instr_count++;
+      } else if (instr_count == 3) {
+        cursor_direction_data[0] = serial_data; //x-direction
+        instr_count++;
+      } else if (instr_count == 4) {
+        cursor_direction_data[1] = serial_data; //y-direction
+        mouse_move(opr_subtype, opr_payload, cursor_direction_data[0], cursor_direction_data[1]);
+        opr_type = OPR_TYPE_RESERVED;
+        instr_count = 0;
+      }
     } else {
       opr_payload = serial_data;
-
-#ifdef ENABLE_DEBUG_PRINT
-      //Debug print the opr sequence
-      Serial0_write(resp_start_of_debug_msg);
-      Serial0_write(opr_type);
-      Serial0_write(opr_subtype);
-      Serial0_write(opr_payload);
-      Serial0_write(resp_end_of_debug_msg);
-#endif
-
       //Execute the kvm operation
       uint8_t err = kvm_execute_opr();
-      if (err != resp_ok) {
-        //Check if there are any execution error. If yes, return error code with 0xEE prefix
-        Serial0_write(resp_start_of_err_msg);
-        Serial0_write(err);
-        Serial0_write(resp_end_of_err_msg);
-      } else {
-        Serial0_write(resp_ok);
-      }
+      Serial0_write(err);
 
       //Reset the instruction counter and ready for the next instruction
       instr_count = 0;