alpha patterns

internal/video/config.go

@@ -40,6 +40,10 @@ func (c Config) Height() uint {
 	return c.Definition.FrameHeight
 }
 
+func (c Config) HasAlpha() bool {
+	return c.Definition.MediaType == flowdef.MediaTypeV210A
+}
+
 func (c Config) Rate() mxl.Rational {
 	return mxl.Rational{
 		Num: int64(c.Definition.GrainRate.Numerator),

internal/video/generator.go

@@ -17,7 +17,31 @@ func newFrameGenerator(cfg Config, pattern pattern) (generator.FrameGenerator, B
 	newCPU := func() (generator.FrameGenerator, error) {
 		return generator.NewCPUPatternGenerator(cfg.Width(), cfg.Height(), cfg.Pattern)
 	}
-	return selectFrameGenerator(cfg.Backend, newGPU, newCPU)
+	fill, backend, err := selectFrameGenerator(cfg.Backend, newGPU, newCPU)
+	if err != nil {
+		return nil, "", err
+	}
+	gen, err := wrapAlphaGenerator(cfg, fill)
+	if err != nil {
+		return nil, "", err
+	}
+	return gen, backend, nil
+}
+
+func wrapAlphaGenerator(cfg Config, fill generator.FrameGenerator) (generator.FrameGenerator, error) {
+	if !cfg.HasAlpha() {
+		return fill, nil
+	}
+
+	gen, err := generator.NewV210AGenerator(fill, cfg.Width(), cfg.Height())
+	if err != nil {
+		closeErr := fill.Close()
+		return nil, errors.Join(
+			fmt.Errorf("initialize v210a generator: %w", err),
+			closeErr,
+		)
+	}
+	return gen, nil
 }
 
 func selectFrameGenerator(

internal/video/generator_test.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"testing"
 
+	"mxl-pattern-generator/internal/flowdef"
 	"mxl-pattern-generator/internal/generator"
 )
 
@@ -110,3 +111,68 @@ func TestSelectFrameGenerator(t *testing.T) {
 		})
 	}
 }
+
+func TestWrapAlphaGenerator(t *testing.T) {
+	const id = "5fbec3b1-1b0f-417d-9059-8b94a47197ed"
+	rate := flowdef.Rational{Numerator: 25, Denominator: 1}
+	tests := []struct {
+		name      string
+		alpha     bool
+		wantAlpha bool
+	}{
+		{name: "v210"},
+		{name: "v210a", alpha: true, wantAlpha: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			var (
+				definition flowdef.Video
+				err        error
+			)
+			if tc.alpha {
+				definition, err = flowdef.NewV210AVideo(id, 100, 200, rate)
+			} else {
+				definition, err = flowdef.NewV210Video(id, 100, 200, rate)
+			}
+			if err != nil {
+				t.Fatalf("create flow definition: %v", err)
+			}
+			cfg := Config{
+				Definition: definition,
+				Pattern:    "gray-ramp",
+				Backend:    BackendCPU,
+			}
+			fill := &stubFrameGenerator{}
+
+			gen, err := wrapAlphaGenerator(cfg, fill)
+			if err != nil {
+				t.Fatalf("wrapAlphaGenerator: %v", err)
+			}
+			defer gen.Close()
+			_, gotAlpha := gen.(*generator.V210AGenerator)
+			if gotAlpha != tc.wantAlpha {
+				t.Errorf("v210a wrapper present = %v, want %v", gotAlpha, tc.wantAlpha)
+			}
+			if !tc.wantAlpha && gen != fill {
+				t.Error("v210 generator was unexpectedly replaced")
+			}
+		})
+	}
+}
+
+func TestConfigHasAlpha(t *testing.T) {
+	for _, tc := range []struct {
+		mediaType string
+		want      bool
+	}{
+		{mediaType: flowdef.MediaTypeV210},
+		{mediaType: flowdef.MediaTypeV210A, want: true},
+		{mediaType: "video/unknown"},
+	} {
+		cfg := Config{Definition: flowdef.Video{Common: flowdef.Common{MediaType: tc.mediaType}}}
+		if got := cfg.HasAlpha(); got != tc.want {
+			t.Errorf("HasAlpha() for %q = %v, want %v", tc.mediaType, got, tc.want)
+		}
+	}
+}

internal/video/runner.go

@@ -36,7 +36,7 @@ func Run(ctx context.Context, inst *mxl.Instance, cfg Config) (runErr error) {
 	}
 
 	var staticFrame []byte
-	if !pattern.dynamic {
+	if !pattern.dynamic && !cfg.HasAlpha() {
 		frameSize := generator.V210FrameSize(int(cfg.Width()), int(cfg.Height()))
 		staticFrame = make([]byte, frameSize)