Added more v4l2 code

remdeskd/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"embed"
+	"flag"
 	"io/fs"
 	"log"
 	"net/http"
@@ -10,12 +11,17 @@ import (
 	"syscall"
 
 	"imuslab.com/remdeskvm/remdeskd/mod/remdeshid"
+	"imuslab.com/remdeskvm/remdeskd/mod/usbcapture"
 )
 
 const development = true
 
 var (
-	remdesHIDController *remdeshid.Controller
+	usbKVMDeviceName  = flag.String("usbkvm", "/dev/ttyUSB0", "USB KVM device file path")
+	usbKVMBaudRate    = flag.Int("baudrate", 115200, "USB KVM baud rate")
+	captureDeviceName = flag.String("capture", "/dev/video0", "Video capture device file path")
+	usbKVM            *remdeshid.Controller
+	videoCapture      *usbcapture.Instance
 )
 
 /* Web Server Static Files */
@@ -37,16 +43,31 @@ func init() {
 	}
 
 	// Initiate the HID controller
-	remdesHIDController = remdeshid.NewHIDController(&remdeshid.Config{
-		PortName: "COM4",
-		BaudRate: 115200,
+	usbKVM = remdeshid.NewHIDController(&remdeshid.Config{
+		PortName: *usbKVMDeviceName,
+		BaudRate: *usbKVMBaudRate,
 	})
 
+	// Initiate the video capture device
+	var err error
+	videoCapture, err = usbcapture.NewInstance(&usbcapture.Config{
+		DeviceName: *captureDeviceName,
+		Resolution: &usbcapture.SizeInfo{
+			Width:  1920,
+			Height: 1080,
+			FPS:    []int{30},
+		},
+	})
+
+	if err != nil {
+		log.Fatalf("Failed to create video capture instance: %v", err)
+	}
+
 }
 
 func main() {
 	//Start the HID controller
-	err := remdesHIDController.Connect()
+	err := usbKVM.Connect()
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -57,12 +78,12 @@ func main() {
 	go func() {
 		<-c
 		log.Println("Shutting down...")
-		remdesHIDController.Close()
+		usbKVM.Close()
 		os.Exit(0)
 	}()
 
 	// Start the web server
-	http.HandleFunc("/hid", remdesHIDController.HIDWebSocketHandler)
+	http.HandleFunc("/hid", usbKVM.HIDWebSocketHandler)
 	http.Handle("/", http.FileServer(webfs))
 	addr := ":8080"
 	log.Printf("Serving on http://localhost%s\n", addr)

remdeskd/mod/usbcapture/usbcapture.go

@@ -8,6 +8,7 @@ import (
 	"mime/multipart"
 	"net/http"
 	"net/textproto"
+	"os"
 	"strings"
 	"syscall"
 
@@ -15,38 +16,72 @@ import (
 	"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
-)
+type Config struct {
+	DeviceName string
+	Resolution *SizeInfo //The prefered resolution to start the video stream
+}
+
+type Instance struct {
+	Config               *Config
+	SupportedResolutions []FormatInfo //The supported resolutions of the video device
+	Capturing            bool
+	camera               *device.Device
+	frames_buff          <-chan []byte
+	pixfmt               v4l2.FourCCType
+	width                int
+	height               int
+	streamInfo           string
+}
+
+// NewInstance creates a new video capture instance
+func NewInstance(config *Config) (*Instance, error) {
+	if config == nil {
+		return nil, fmt.Errorf("config cannot be nil")
+	}
+
+	//Check if the video device exists
+	if _, err := os.Stat(config.DeviceName); os.IsNotExist(err) {
+		return nil, fmt.Errorf("video device %s does not exist", config.DeviceName)
+	} else if err != nil {
+		return nil, fmt.Errorf("failed to check video device: %w", err)
+	}
+
+	//Check if the device file actualy points to a video device
+	isValidDevice, err := checkVideoCaptureDevice(config.DeviceName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check video device: %w", err)
+	}
+
+	if !isValidDevice {
+		return nil, fmt.Errorf("device %s is not a video capture device", config.DeviceName)
+	}
+
+	//Get the supported resolutions of the video device
+	formatInfo, err := GetV4L2FormatInfo(config.DeviceName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get video device format info: %w", err)
+	}
+
+	if len(formatInfo) == 0 {
+		return nil, fmt.Errorf("no supported formats found for device %s", config.DeviceName)
+	}
+
+	return &Instance{
+		Config:               config,
+		Capturing:            false,
+		SupportedResolutions: formatInfo,
+	}, nil
+}
 
 // start http service
-func serveVideoStream(w http.ResponseWriter, req *http.Request) {
+func (i *Instance) 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 {
+	for frame = range i.frames_buff {
 		if len(frame) == 0 {
 			log.Print("skipping empty frame")
 			continue
@@ -69,46 +104,64 @@ func serveVideoStream(w http.ResponseWriter, req *http.Request) {
 	}
 }
 
-// startVideoServer starts the video server
-func startVideoServer() {
-	port := ":9090"
-	devName := "/dev/video0"
-	frameRate := int(fps)
+// start video capture
+func (i *Instance) StartVideoCapture(selectedFPS int) error {
+	if i.Capturing {
+		return fmt.Errorf("video capture already started")
+	}
+
+	devName := i.Config.DeviceName
+	frameRate := 25
 	buffSize := 8
 	format := "mjpeg"
 
+	if i.Config.Resolution == nil {
+		return fmt.Errorf("resolution not provided")
+	}
+
+	//Check if the selected FPS is valid in the provided Resolutions
+	if i.Config.Resolution != nil {
+		for _, size := range i.Config.Resolution.FPS {
+			if size == selectedFPS {
+				frameRate = size
+				break
+			}
+		}
+
+		if frameRate != selectedFPS {
+			log.Printf("selected FPS %d is not supported, using default %d", selectedFPS, frameRate)
+		}
+	} else {
+		log.Printf("no resolution provided, using default %d", frameRate)
+	}
+
 	//Check if the video device is a capture device
 	isCaptureDev, err := checkVideoCaptureDevice(devName)
 	if err != nil {
-		panic(err)
+		return fmt.Errorf("failed to check video device: %w", err)
 	}
 	if !isCaptureDev {
-		panic("target device is not a capture-able device")
+		return fmt.Errorf("device %s is not a video capture device", devName)
 	}
+
+	//Open the video 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.WithPixFormat(v4l2.PixFormat{
+			PixelFormat: getFormatType(format),
+			Width:       uint32(i.Config.Resolution.Width),
+			Height:      uint32(i.Config.Resolution.Height),
+			Field:       v4l2.FieldAny,
+		}),
 		device.WithFPS(uint32(frameRate)),
 		device.WithBufferSize(uint32(buffSize)),
 	)
 
 	if err != nil {
-		log.Fatalf("failed to open device: %s", err)
+		return fmt.Errorf("failed to open video device: %w", 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)
-		}
-	}
+	i.camera = camera
 
 	caps := camera.Capability()
 	log.Printf("device [%s] opened\n", devName)
@@ -122,8 +175,11 @@ func startVideoServer() {
 	}
 	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",
+	i.pixfmt = currFmt.PixelFormat
+	i.width = int(currFmt.Width)
+	i.height = int(currFmt.Height)
+
+	i.streamInfo = fmt.Sprintf("%s - %s [%dx%d] %d fps",
 		caps.Card,
 		v4l2.PixelFormats[currFmt.PixelFormat],
 		currFmt.Width, currFmt.Height, frameRate,
@@ -140,17 +196,40 @@ func startVideoServer() {
 	}()
 
 	// video stream
-	frames = camera.GetOutput()
+	i.frames_buff = 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")
+	i.Capturing = true
+	return nil
+}
+
+// GetStreamInfo returns the stream information string
+func (i *Instance) GetStreamInfo() string {
+	return i.streamInfo
+}
+
+// IsCapturing checks if the camera is currently capturing video
+func (i *Instance) IsCapturing() bool {
+	return i.Capturing
+}
+
+// StopCapture stops the video capture and closes the camera device
+func (i *Instance) StopCapture() error {
+	if i.camera != nil {
+		i.camera.Stop()
+		i.camera.Close()
+		i.camera = nil
+	}
+	i.Capturing = false
+	return nil
+}
 
-	// setup http service
-	http.HandleFunc("/stream", serveVideoStream) // returns video feed
-	if err := http.ListenAndServe(port, nil); err != nil {
-		log.Fatal(err)
+// Close closes the camera device and releases resources
+func (i *Instance) Close() error {
+	if i.camera != nil {
+		i.StopCapture()
 	}
+	return nil
 }
 
 func getFormatType(fmtStr string) v4l2.FourCCType {

remdeskd/mod/usbcapture/video_device.go

@@ -10,6 +10,20 @@ import (
 	"strings"
 )
 
+/*
+	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
+*/
+
 // Struct to store the size and fps info
 type FormatInfo struct {
 	Format string
@@ -19,7 +33,7 @@ type FormatInfo struct {
 type SizeInfo struct {
 	Width  int
 	Height int
-	FPS    []float64
+	FPS    []int
 }
 
 // CheckVideoCaptureDevice checks if the given video device is a video capture device
@@ -39,8 +53,37 @@ func checkVideoCaptureDevice(device string) (bool, error) {
 	return false, nil
 }
 
+func PrintV4L2FormatInfo(devicePath string) {
+	// Check if the device is a video capture device
+	isCapture, err := checkVideoCaptureDevice(devicePath)
+	if err != nil {
+		fmt.Printf("Error checking device: %v\n", err)
+		return
+	}
+	if !isCapture {
+		fmt.Printf("Device %s is not a video capture device\n", devicePath)
+		return
+	}
+
+	// Get format info
+	formats, err := GetV4L2FormatInfo(devicePath)
+	if err != nil {
+		fmt.Printf("Error getting format info: %v\n", err)
+		return
+	}
+
+	// Print format info
+	for _, format := range formats {
+		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)
+		}
+	}
+}
+
 // Function to run the v4l2-ctl command and parse the output
-func getV4L2FormatInfo(devicePath string) ([]FormatInfo, error) {
+func GetV4L2FormatInfo(devicePath string) ([]FormatInfo, error) {
 	// Run the v4l2-ctl command to list formats
 	cmd := exec.Command("v4l2-ctl", "--list-formats-ext", "-d", devicePath)
 	var out bytes.Buffer
@@ -88,8 +131,8 @@ func getV4L2FormatInfo(devicePath string) ([]FormatInfo, error) {
 			for scanner.Scan() {
 				line = scanner.Text()
 				if fpsMatches := intervalRegex.FindStringSubmatch(line); fpsMatches != nil {
-					fps, _ := strconv.ParseFloat(fpsMatches[2], 64)
-					sizeInfo.FPS = append(sizeInfo.FPS, fps)
+					fps, _ := strconv.ParseInt(fpsMatches[2], 10, 0)
+					sizeInfo.FPS = append(sizeInfo.FPS, int(fps))
 				} else {
 					// Stop parsing FPS intervals when no more matches are found
 					break