alpha patterns

cmd/mxl-pattern/main.go

@@ -48,6 +48,7 @@ type appArgs struct {
 	videoFPS     string
 	videoUUID    string
 	noVideo      bool
+	videoAlpha   bool
 	videoBackend string
 
 	audioChannels     uint8
@@ -173,6 +174,12 @@ func validateMediaSelection(args appArgs) error {
 	if args.noVideo && args.audioFlowDefFile == "" && args.audioChannels == 0 {
 		return fmt.Errorf("--no-video requires audio enabled with --channel or --audio")
 	}
+	if args.videoAlpha && args.noVideo {
+		return fmt.Errorf("--alpha cannot be used with --no-video")
+	}
+	if args.videoAlpha && args.videoFlowDefFile != "" {
+		return fmt.Errorf("--alpha cannot be used with --video; set media_type to %q in the flow definition", flowdef.MediaTypeV210A)
+	}
 	return nil
 }
 
@@ -287,6 +294,7 @@ func addFlags(fs *pflag.FlagSet, args *appArgs) {
 	fs.StringVar(&args.videoFPS, "fps", "25", "Video pattern FPS")
 	fs.StringVar(&args.videoUUID, "video-id", "", "Video UUID. Will be created, if not provided")
 	fs.BoolVar(&args.noVideo, "no-video", false, "Disable video generation; audio must be enabled")
+	fs.BoolVar(&args.videoAlpha, "alpha", false, "Generate video/v210a with a moving transparent square")
 	fs.StringVar(&args.videoBackend, "backend", string(video.BackendAuto), "Video generator backend: auto, gpu or cpu")
 	// Audio pattern flags
 	fs.Uint8VarP(&args.audioChannels, "channel", "c", 0, "Amount of audio channels. Each channel: num * 1kHz")
@@ -370,7 +378,11 @@ func buildVideoConfig(args appArgs) (*video.Config, error) {
 		}
 
 		var err error
-		definition, err = flowdef.NewV210Video(
+		newVideo := flowdef.NewV210Video
+		if args.videoAlpha {
+			newVideo = flowdef.NewV210AVideo
+		}
+		definition, err = newVideo(
 			args.videoUUID,
 			args.videoWidth,
 			args.videoHeight,

cmd/mxl-pattern/main_test.go

@@ -10,8 +10,22 @@ import (
 	"mxl-pattern-generator/internal/audio"
 	"mxl-pattern-generator/internal/flowdef"
 	"mxl-pattern-generator/internal/video"
+
+	"github.com/spf13/pflag"
 )
 
+func TestAlphaFlag(t *testing.T) {
+	var args appArgs
+	flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
+	addFlags(flags, &args)
+	if err := flags.Parse([]string{"--alpha"}); err != nil {
+		t.Fatalf("Parse: %v", err)
+	}
+	if !args.videoAlpha {
+		t.Fatal("videoAlpha = false, want true")
+	}
+}
+
 func TestParseArgsHelpStopsBeforeValidation(t *testing.T) {
 	var stdout, stderr bytes.Buffer
 
@@ -181,6 +195,16 @@ func TestValidateMediaSelection(t *testing.T) {
 			name: "video enabled by default",
 			args: appArgs{},
 		},
+		{
+			name:       "alpha without video",
+			args:       appArgs{noVideo: true, videoAlpha: true, audioChannels: 2},
+			wantErrSub: "cannot be used with --no-video",
+		},
+		{
+			name:       "alpha with custom video definition",
+			args:       appArgs{videoAlpha: true, videoFlowDefFile: "video.json"},
+			wantErrSub: "cannot be used with --video",
+		},
 	}
 
 	for _, tc := range tests {
@@ -233,6 +257,26 @@ func TestBuildVideoConfigFromArgs(t *testing.T) {
 	}
 }
 
+func TestBuildVideoConfigWithAlpha(t *testing.T) {
+	cfg, err := buildVideoConfig(appArgs{
+		videoUUID:   "5fbec3b1-1b0f-417d-9059-8b94a47197ed",
+		videoWidth:  1280,
+		videoHeight: 720,
+		videoFPS:    "50",
+		pattern:     "gray-ramp",
+		videoAlpha:  true,
+	})
+	if err != nil {
+		t.Fatalf("buildVideoConfig: %v", err)
+	}
+	if cfg.Definition.MediaType != flowdef.MediaTypeV210A {
+		t.Fatalf("media type = %q, want %q", cfg.Definition.MediaType, flowdef.MediaTypeV210A)
+	}
+	if !cfg.HasAlpha() {
+		t.Fatal("HasAlpha() = false, want true")
+	}
+}
+
 func TestBuildVideoConfigBackends(t *testing.T) {
 	for _, backend := range []video.Backend{video.BackendGPU, video.BackendCPU} {
 		t.Run(string(backend), func(t *testing.T) {