feat: Enhance configuration options in README and environment file for video and audio settings

Author: 02loveslollipop

sbc_streamer/README.md

@@ -14,18 +14,28 @@ The streamer is configured through environment variables (values shown with defa
 
 | Variable | Description |
 | --- | --- |
-| `FFMPEG_BINARY=ffmpeg` | Path to the `ffmpeg` executable (set to `/usr/local/bin/ffmpeg` when using a custom build) |
+| `FFMPEG_BINARY=ffmpeg` | Path to the `ffmpeg` executable |
 | `CAMERA_DEVICE=/dev/video0` | Video4Linux device supplying the camera feed |
 | `AUDIO_DEVICE` | Optional ALSA device (e.g. `hw:1,0`) to include audio |
 | `INPUT_FORMAT` | Force a V4L2 input format (e.g. `mjpeg`, `yuyv422`) when autodetect fails |
 | `FRAME_RATE=30` | Capture frame rate |
 | `VIDEO_SIZE=1280x720` | Capture resolution |
-| `VIDEO_BITRATE=1500k` | Target video bitrate |
+| `VIDEO_BITRATE=2M` | Target average video bitrate |
+| `VIDEO_MAXRATE=2M` | Peak video bitrate (CBR-style when set equal to `VIDEO_BITRATE`) |
+| `VIDEO_BUFSIZE=2M` | Encoder buffer size |
+| `VIDEO_CODEC=h264_rkmpp` | Video encoder (Rockchip hardware encoder by default) |
+| `VIDEO_FORMAT=nv12` | Pixel format fed into the encoder |
 | `STREAM_NAME=robot` | Path name on the relay |
-| `RELAY_HOST=rtsp.nene.02labs.me:8554` | Relay host (host:port) |
+| `RELAY_HOST=rtsp.02labs.me:8554` | Relay host (host:port) |
 | `RELAY_PUBLISH_USER` | Username for RTSP publish authentication |
 | `RELAY_PUBLISH_PASS` | Password for RTSP publish authentication |
 | `RTSP_TRANSPORT=tcp` | Transport to use when pushing (`tcp` or `udp`) |
+| `AUDIO_BITRATE=128k` | Audio bitrate when audio is enabled |
+| `AUDIO_SAMPLE_RATE=48000` | Audio sampling rate |
+| `AUDIO_CHANNELS=2` | Number of audio channels |
+| `GENERATE_SINE_AUDIO=true` | Generate a synthetic sine wave when no audio device is supplied |
+| `SINE_FREQUENCY=1000` | Frequency (Hz) of the synthetic sine tone |
+| `USE_TEST_PATTERN=false` | When `true`, push a `testsrc` pattern instead of the camera |
 
 ## Building
 
@@ -78,5 +88,7 @@ The service will restart automatically if `ffmpeg` exits and will reconnect afte
 
 ## Hardware acceleration tips
 
-- For Rockchip hardware encoding, install an `ffmpeg` build compiled with `--enable-rkmpp` or the V4L2 request API and set `FFMPEG_BINARY=/usr/local/bin/ffmpeg` (or whichever path hosts your accelerated binary).
-- Update the streamer source if you need to switch codecs (for example, replace `libx264` with `h264_rkmpp`). After editing, rebuild the binary with `go build`.
+- The default pipeline now matches the Rockchip GPU sweet spot: 1280x720 @30 fps, NV12 frames, and `h264_rkmpp` with 2 Mbps CBR.
+- Ensure the SBC is running an `ffmpeg` build compiled with `--enable-rkmpp` (the provided Radxa builds usually ship this; the custom binary you installed is assumed to replace `ffmpeg`).
+- Adjust the `VIDEO_*` variables if you need different bitrates or resolutions, but keep an eye on encoder limits.
+- Set `USE_TEST_PATTERN=true` to emit the synthetic `testsrc` pattern while commissioning the pipeline.

sbc_streamer/main.go

@@ -7,23 +7,34 @@ import (
 	"os"
 	"os/exec"
 	"os/signal"
+	"strings"
 	"syscall"
 	"time"
 )
 
 type streamerConfig struct {
-	ffmpegBinary  string
-	cameraDevice  string
-	audioDevice   string
-	frameRate     string
-	resolution    string
-	bitrate       string
-	streamName    string
-	targetHost    string
-	publishUser   string
-	publishPass   string
-	rtspTransport string
-	inputFormat   string
+	ffmpegBinary      string
+	cameraDevice      string
+	audioDevice       string
+	frameRate         string
+	resolution        string
+	videoBitrate      string
+	videoMaxRate      string
+	videoBufSize      string
+	videoCodec        string
+	videoFormat       string
+	streamName        string
+	targetHost        string
+	publishUser       string
+	publishPass       string
+	rtspTransport     string
+	inputFormat       string
+	audioBitrate      string
+	audioSampleRate   string
+	audioChannels     string
+	sineFrequency     string
+	generateSineAudio bool
+	useTestPattern    bool
 }
 
 func main() {
@@ -60,19 +71,30 @@ func main() {
 }
 
 func loadConfig() streamerConfig {
+	baseBitrate := readEnv("VIDEO_BITRATE", "2M")
 	return streamerConfig{
-		ffmpegBinary:  readEnv("FFMPEG_BINARY", "ffmpeg"),
-		cameraDevice:  readEnv("CAMERA_DEVICE", "/dev/video0"),
-		audioDevice:   os.Getenv("AUDIO_DEVICE"),
-		frameRate:     readEnv("FRAME_RATE", "30"),
-		resolution:    readEnv("VIDEO_SIZE", "1280x720"),
-		bitrate:       readEnv("VIDEO_BITRATE", "1500k"),
-		streamName:    readEnv("STREAM_NAME", "robot"),
-		targetHost:    readEnv("RELAY_HOST", "rtsp.nene.02labs.me:8554"),
-		publishUser:   readEnv("RELAY_PUBLISH_USER", ""),
-		publishPass:   readEnv("RELAY_PUBLISH_PASS", ""),
-		rtspTransport: readEnv("RTSP_TRANSPORT", "tcp"),
-		inputFormat:   os.Getenv("INPUT_FORMAT"),
+		ffmpegBinary:      readEnv("FFMPEG_BINARY", "ffmpeg"),
+		cameraDevice:      readEnv("CAMERA_DEVICE", "/dev/video0"),
+		audioDevice:       os.Getenv("AUDIO_DEVICE"),
+		frameRate:         readEnv("FRAME_RATE", "30"),
+		resolution:        readEnv("VIDEO_SIZE", "1280x720"),
+		videoBitrate:      baseBitrate,
+		videoMaxRate:      readEnv("VIDEO_MAXRATE", baseBitrate),
+		videoBufSize:      readEnv("VIDEO_BUFSIZE", baseBitrate),
+		videoCodec:        readEnv("VIDEO_CODEC", "h264_rkmpp"),
+		videoFormat:       readEnv("VIDEO_FORMAT", "nv12"),
+		streamName:        readEnv("STREAM_NAME", "robot"),
+		targetHost:        readEnv("RELAY_HOST", "rtsp.02labs.me:8554"),
+		publishUser:       readEnv("RELAY_PUBLISH_USER", ""),
+		publishPass:       readEnv("RELAY_PUBLISH_PASS", ""),
+		rtspTransport:     readEnv("RTSP_TRANSPORT", "tcp"),
+		inputFormat:       os.Getenv("INPUT_FORMAT"),
+		audioBitrate:      readEnv("AUDIO_BITRATE", "128k"),
+		audioSampleRate:   readEnv("AUDIO_SAMPLE_RATE", "48000"),
+		audioChannels:     readEnv("AUDIO_CHANNELS", "2"),
+		sineFrequency:     readEnv("SINE_FREQUENCY", "1000"),
+		generateSineAudio: readEnvBool("GENERATE_SINE_AUDIO", true),
+		useTestPattern:    readEnvBool("USE_TEST_PATTERN", false),
 	}
 }
 
@@ -92,50 +114,54 @@ func runFFmpeg(ctx context.Context, cfg streamerConfig, logger *log.Logger) erro
 }
 
 func buildFFmpegArgs(cfg streamerConfig) []string {
-	args := []string{
-		"-f", "v4l2",
-	}
-	if cfg.inputFormat != "" {
-		args = append(args, "-input_format", cfg.inputFormat)
+	args := []string{"-re"}
+
+	if cfg.useTestPattern {
+		args = append(args,
+			"-f", "lavfi",
+			"-i", fmt.Sprintf("testsrc=size=%s:rate=%s", cfg.resolution, cfg.frameRate),
+		)
+	} else {
+		args = append(args, "-f", "v4l2")
+		if cfg.inputFormat != "" {
+			args = append(args, "-input_format", cfg.inputFormat)
+		}
+		args = append(args,
+			"-thread_queue_size", "256",
+			"-framerate", cfg.frameRate,
+			"-video_size", cfg.resolution,
+			"-i", cfg.cameraDevice,
+		)
 	}
-	args = append(args,
-		"-thread_queue_size", "256",
-		"-framerate", cfg.frameRate,
-		"-video_size", cfg.resolution,
-		"-i", cfg.cameraDevice,
-	)
 
 	if cfg.audioDevice != "" {
-		audioArgs := []string{
+		args = append(args,
 			"-f", "alsa",
 			"-thread_queue_size", "256",
 			"-i", cfg.audioDevice,
-		}
-		args = append(args, audioArgs...)
+		)
+	} else if cfg.generateSineAudio {
+		args = append(args,
+			"-f", "lavfi",
+			"-i", fmt.Sprintf("sine=frequency=%s:sample_rate=%s", cfg.sineFrequency, cfg.audioSampleRate),
+		)
 	}
 
-	videoOut := []string{
-		"-vf", "format=yuv420p",
-		"-c:v", "libx264",
-		"-preset", "ultrafast",
-		"-tune", "zerolatency",
-		"-pix_fmt", "yuv420p",
-		"-b:v", cfg.bitrate,
-		"-maxrate", cfg.bitrate,
-		"-bufsize", cfg.bitrate,
-		"-g", "60",
-		"-keyint_min", "30",
-	}
-	args = append(args, videoOut...)
+	args = append(args,
+		"-vf", fmt.Sprintf("format=%s", cfg.videoFormat),
+		"-c:v", cfg.videoCodec,
+		"-b:v", cfg.videoBitrate,
+		"-maxrate", cfg.videoMaxRate,
+		"-bufsize", cfg.videoBufSize,
+	)
 
-	if cfg.audioDevice != "" {
-		audioOut := []string{
+	if cfg.audioDevice != "" || cfg.generateSineAudio {
+		args = append(args,
 			"-c:a", "aac",
-			"-b:a", "128k",
-			"-ar", "48000",
-			"-ac", "2",
-		}
-		args = append(args, audioOut...)
+			"-b:a", cfg.audioBitrate,
+			"-ar", cfg.audioSampleRate,
+			"-ac", cfg.audioChannels,
+		)
 	}
 
 	args = append(args,
@@ -167,3 +193,18 @@ func readEnv(key, fallback string) string {
 	}
 	return fallback
 }
+
+func readEnvBool(key string, fallback bool) bool {
+	v, ok := os.LookupEnv(key)
+	if !ok || v == "" {
+		return fallback
+	}
+	switch strings.ToLower(v) {
+	case "1", "true", "t", "yes", "y":
+		return true
+	case "0", "false", "f", "no", "n":
+		return false
+	default:
+		return fallback
+	}
+}

sbc_streamer/streamer.example.env

@@ -1,22 +1,35 @@
 # Example environment file for the Radxa SBC streamer
 
 # Path to the accelerated ffmpeg binary
-FFMPEG_BINARY=/usr/local/bin/ffmpeg
+# Only override when ffmpeg is not on PATH or uses a custom name
+#FFMPEG_BINARY=/usr/local/bin/ffmpeg
 
 # Video source configuration
 CAMERA_DEVICE=/dev/video0
 FRAME_RATE=30
 VIDEO_SIZE=1280x720
-VIDEO_BITRATE=1500k
+VIDEO_BITRATE=2M
+VIDEO_MAXRATE=2M
+VIDEO_BUFSIZE=2M
+#VIDEO_CODEC=h264_rkmpp
+#VIDEO_FORMAT=nv12
 # Uncomment if the camera requires a specific pixel format (e.g. mjpeg)
 #INPUT_FORMAT=mjpeg
 
-# Optional audio source (ALSA device ID), leave empty to disable audio capture
+# Optional audio source (ALSA device ID); leave empty to synthesize a tone
 #AUDIO_DEVICE=hw:1,0
+#AUDIO_BITRATE=128k
+#AUDIO_SAMPLE_RATE=48000
+#AUDIO_CHANNELS=2
+#GENERATE_SINE_AUDIO=true
+#SINE_FREQUENCY=1000
 
 # Relay connection details
-RELAY_HOST=rtsp.nene.02labs.me:8554
+RELAY_HOST=rtsp.02labs.me:8554
 RELAY_PUBLISH_USER=robot
 RELAY_PUBLISH_PASS=replace-with-strong-secret
 STREAM_NAME=robot
 RTSP_TRANSPORT=tcp
+
+# Set to true to push a color bars test pattern instead of the camera
+#USE_TEST_PATTERN=false