feat: Add streaming and window recording

 This commit tries implementing the ability to stream a display and record a specific window.

  The main changes are:
   - Added a new "Stream a display" option to the main menu, which utilizes ddagrab for efficient screen capture.
   - Tried implementing window recording functionality.
   - Added a new stream_config to the config file to store stream keys.
   - Improved FFmpeg argument handling in recscreen.go.
   - Added cleanup for downloaded FFmpeg files.
   - Made config file handling more robust.

Author: ServerDeveloper9447

main.go

@@ -28,7 +28,6 @@ var (
 		RecordingOpts: RecordingOptions{
 			FPS:          30,
 			CaptureMouse: true,
-			AudioDevice:  "",
 		},
 		HotkeyConfig: hotkeyConfig{
 			Modkeys:  []string{"ctrl", "shift"},
@@ -61,7 +60,6 @@ func extractFFmpegExe(zipPath, destDir string) error {
 			defer outFile.Close()
 
 			_, err = io.Copy(outFile, rc)
-			os.Remove(zipPath)
 			return err
 		}
 	}
@@ -75,11 +73,17 @@ type hotkeyConfig struct {
 	Note     string   `json:"note"`
 }
 
+type streamConfig struct {
+	YoutubeStreamKey string `json:"ytstreamkey"`
+	TwitchStreamKey  string `json:"twitchstreamkey"`
+}
+
 type Config struct {
 	SaveLocation  string           `json:"save_location"`
 	RecordFunc    bool             `json:"record_func_enabled"`
 	RecordingOpts RecordingOptions `json:"recording_options,omitempty"`
 	HotkeyConfig  hotkeyConfig     `json:"hotkey_config"`
+	StreamConfig  streamConfig     `json:"stream_config"`
 }
 
 type RecordingOptions struct {
@@ -111,7 +115,7 @@ func initConfig() {
 		}
 		var loadedConfig Config
 		if err := json.Unmarshal(data, &loadedConfig); err != nil {
-			panic(err)
+			os.WriteFile(configFilePath, []byte{'{', '}'}, 0644)
 		}
 
 		config = mergeConfig(defaultConfig, loadedConfig)
@@ -186,6 +190,7 @@ func initDownloads() {
 		tasks.Add("https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n7.1-latest-win64-gpl-7.1.zip", filepath.Join(dwnPath, "ffmpeg_captr.zip"), progressbar.WithBarSpinner(51))
 		tasks.Add("https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/checksums.sha256", filepath.Join(dwnPath, "checksums.sha256"), progressbar.WithBarSpinner(51))
 		tasks.Wait()
+		tasks.Close()
 		fmt.Println("Checking sha256 hash of the downloaded file.")
 		file, err := os.ReadFile(filepath.Join(dwnPath, "checksums.sha256"))
 		if err != nil {
@@ -200,20 +205,22 @@ func initDownloads() {
 				shaHash := strings.Split(line, " ")[0]
 				f, err := os.Open(filepath.Join(dwnPath, "ffmpeg_captr.zip"))
 				if err != nil {
+					f.Close()
 					fmt.Println(err)
 					fmt.Println("Cannot match checksum file of the download. Aborting install...")
 					os.Remove(filepath.Join(dwnPath, "checksums.sha256"))
 					os.Remove(filepath.Join(dwnPath, "ffmpeg_captr.zip"))
 					os.Exit(1)
 				}
-				defer f.Close()
 				h := sha256.New()
 				if _, err := io.Copy(h, f); err != nil {
+					f.Close()
 					fmt.Println("Cannot generate sha256 for the download. Aborting install...")
 					os.Remove(filepath.Join(dwnPath, "checksums.sha256"))
 					os.Remove(filepath.Join(dwnPath, "ffmpeg_captr.zip"))
 					os.Exit(1)
 				}
+				f.Close()
 				if shaHash != fmt.Sprintf("%x", h.Sum(nil)) {
 					fmt.Println("SHA256 hash unmatched for the downloaded file. Install aborted.")
 					fmt.Printf("Expected hash: %s\nHash got: %x", shaHash, h.Sum(nil))
@@ -223,7 +230,19 @@ func initDownloads() {
 				}
 			}
 		}
-		extractFFmpegExe(filepath.Join(dwnPath, "ffmpeg_captr.zip"), dwnPath)
+		err = extractFFmpegExe(filepath.Join(dwnPath, "ffmpeg_captr.zip"), dwnPath)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		err = os.Remove(filepath.Join(dwnPath, "checksums.sha256"))
+		if err != nil {
+			fmt.Println(err)
+		}
+		err = os.Remove(filepath.Join(dwnPath, "ffmpeg_captr.zip"))
+		if err != nil {
+			fmt.Println(err)
+		}
 		fmt.Printf("FFMPEG has been downloaded to %s", dwnPath)
 	} else {
 		setConfig("record_func_enabled", false)
@@ -300,7 +319,7 @@ v1.0.2
 
 `)
 	fmt.Println("Open config file by passing the --config flag")
-	capture_ops := []string{"Record full screen", "Record specific window", "Screenshot specific window", "Screenshot full screen"}
+	capture_ops := []string{"Record full screen", "Record specific window", "Screenshot specific window", "Screenshot full screen", "Stream a display"}
 	var i int
 	err := survey.AskOne(&survey.Select{
 		Message: "Select Action",
@@ -315,9 +334,13 @@ v1.0.2
 	switch i {
 	case 0:
 		RecordDisplay()
+	case 1:
+		RecordWindow()
 	case 2:
 		Screenshot_Window()
 	case 3:
 		Screenshot_Display()
+	case 4:
+		StreamDisp()
 	}
 }

recscreen.go

@@ -68,27 +68,24 @@ func RecordDisplay() {
 		Options: displays,
 	}, &display, survey.WithValidator(survey.Required))
 	if err != nil {
-		fmt.Print("Some error occurred")
+		fmt.Print("Action Aborted")
 		return
 	}
 
-	x, y, w, h := robotgo.GetDisplayBounds(display)
+	_, _, w, h := robotgo.GetDisplayBounds(display)
 	filename := filepath.Join(config.SaveLocation, fmt.Sprintf("Recording_Disp%d_%dx%d_%s.mp4", display+1, w, h, time.Now().Format("20060102_150405")))
 	args := []string{
-		"-f", "gdigrab",
-		"-framerate", fmt.Sprintf("%d", config.RecordingOpts.FPS),
-		"-offset_x", strconv.Itoa(x),
-		"-offset_y", strconv.Itoa(y),
+		"-filter_complex", fmt.Sprintf("ddagrab=output_idx=%d:framerate=%d,hwdownload,format=bgra", display, config.RecordingOpts.FPS),
 		"-video_size", fmt.Sprintf("%dx%d", w, h),
 		"-draw_mouse", ternary(config.RecordingOpts.CaptureMouse, "1", "0"),
-		"-i", "desktop",
 		"-c:v", "libx264",
 		"-preset", "ultrafast",
 		"-profile:v", "main",
 		"-level", "4.0",
 		"-pix_fmt", "yuv420p",
 		"-c:a", "aac",
 		"-movflags", "+faststart",
+		"-f", "mp4",
 		"-y", filename,
 	}
 

recwindow.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+
+	"strings"
+	"time"
+
+	"github.com/go-toast/toast"
+	"golang.design/x/hotkey"
+)
+
+func RecordWindow() {
+	hwnd := chooseWindow()
+	ActivateWindowAndGetBounds(uintptr(hwnd))
+	filename := filepath.Join(config.SaveLocation, fmt.Sprintf("Recording_%s.mp4", time.Now().Format("20060102_150405")))
+	args := []string{
+		"-f", "gdigrab",
+		"-framerate", fmt.Sprintf("%d", config.RecordingOpts.FPS),
+		"-draw_mouse", ternary(config.RecordingOpts.CaptureMouse, "1", "0"),
+		"-show_region", "1",
+		"-i", fmt.Sprintf("hwnd=%d", uintptr(hwnd)),
+		"-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
+		"-c:v", "libx264",
+		"-preset", "ultrafast",
+		"-profile:v", "main",
+		"-level", "4.0",
+		"-pix_fmt", "yuv420p",
+		"-movflags", "+faststart",
+		"-y", filename,
+	}
+
+	cmd := exec.Command(getFfmpegPath(), args...)
+	cmd.Stderr = os.Stderr
+	cmd.Stdout = os.Stdout
+	stdin, _ := cmd.StdinPipe()
+	var start time.Time
+	var err error
+	if err, start = cmd.Start(), time.Now(); err != nil {
+		fmt.Println("Error starting ffmpeg:", err)
+		return
+	}
+
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("\nUnexpected error:", r)
+		}
+		exec.Command("taskkill", "/T", "/F", "/PID", strconv.Itoa(cmd.Process.Pid)).Run()
+	}()
+
+	var modkeys []hotkey.Modifier
+	pressedKeys := map[string]bool{}
+	for _, key := range config.HotkeyConfig.Modkeys {
+		pressedKeys[key] = true
+	}
+	for _, mod := range []string{"ctrl", "alt", "shift"} {
+		if pressedKeys[mod] {
+			switch mod {
+			case "ctrl":
+				modkeys = append(modkeys, hotkey.ModCtrl)
+			case "alt":
+				modkeys = append(modkeys, hotkey.ModAlt)
+			case "shift":
+				modkeys = append(modkeys, hotkey.ModShift)
+			}
+		}
+	}
+	fmt.Printf("Recording started. Press %s to stop\n", strings.Join(append(config.HotkeyConfig.Modkeys, config.HotkeyConfig.Finalkey), "+"))
+	tickStop := make(chan struct{})
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+	i := 0
+	last := []string{"🔴", "⚫"}
+	go func() {
+		for {
+			select {
+			case <-ticker.C:
+				fmt.Printf("\r%s Recording time elapsed: %02d:%02d", last[i], int(time.Since(start).Minutes()), int(time.Since(start).Seconds())%60)
+				i = (i + 1) % 2
+			case <-tickStop:
+			}
+		}
+	}()
+	go func() {
+		err = cmd.Wait()
+		if err != nil {
+			fmt.Println("Error waiting for ffmpeg to exit:", err)
+		}
+	}()
+	hk := hotkey.New(modkeys, keys[config.HotkeyConfig.Finalkey])
+	err = hk.Register()
+	if err != nil {
+		fmt.Println("Error registering hotkey:", err)
+		return
+	}
+	defer hk.Unregister()
+	keyChan := hk.Keydown()
+	for range keyChan {
+		tickStop <- struct{}{}
+		stdin.Write([]byte("q"))
+		stdin.Close()
+		fmt.Println("\nStopping recording...")
+		notification := toast.Notification{
+			AppID:               "Captr",
+			Title:               "Recording Stopped",
+			Message:             fmt.Sprintf("Recording saved at %s", filename),
+			Icon:                filename,
+			ActivationArguments: filename,
+			Audio:               toast.IM,
+			Actions: []toast.Action{
+				{Type: "protocol", Label: "Open", Arguments: filename},
+			},
+		}
+		notification.Push()
+		break
+	}
+
+	fmt.Printf("\nRecording stopped. Recording saved at %s", filename)
+}