@machinal/scenes 0.0.0-stage → 0.1.0

package/renderer/output.go

@@ -0,0 +1,93 @@
+package sceneengine
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+func stageOutput(output string) (string, error) {
+	if _, err := os.Stat(output); err == nil {
+		return "", fmt.Errorf("output already exists: %s", output)
+	} else if !os.IsNotExist(err) {
+		return "", fmt.Errorf("inspect output: %w", err)
+	}
+	if _, err := os.Stat(output + ".scene.json"); err == nil {
+		return "", fmt.Errorf("asset manifest already exists: %s.scene.json", output)
+	} else if !os.IsNotExist(err) {
+		return "", fmt.Errorf("inspect asset manifest: %w", err)
+	}
+	staged, err := os.CreateTemp(filepath.Dir(output), ".scene-*"+filepath.Ext(output))
+	if err != nil {
+		return "", fmt.Errorf("stage video output: %w", err)
+	}
+	if err := staged.Close(); err != nil {
+		os.Remove(staged.Name())
+		return "", fmt.Errorf("close staged output: %w", err)
+	}
+	return staged.Name(), nil
+}
+
+func publishOutput(staged, output string, request Request, manifest Manifest, codec Codec, elapsed time.Duration, metrics RenderMetrics) (Result, error) {
+	hash, size, err := fingerprint(staged)
+	if err != nil {
+		return Result{}, err
+	}
+	absolute, err := filepath.Abs(output)
+	if err != nil {
+		return Result{}, fmt.Errorf("resolve output path: %w", err)
+	}
+	result := Result{Version: ProtocolVersion, File: absolute, SHA256: hash, Size: size, Duration: request.Config.Duration(), Width: request.Config.Width, Height: request.Config.Height, FPS: request.Config.FPS, Frames: request.Config.DurationInFrames, HasAudio: len(request.Audio) > 0, Transparent: request.Config.Transparent, Codec: codec, Scene: manifest, Elapsed: elapsed}
+	result.Metrics = metrics
+	data, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		return Result{}, fmt.Errorf("encode asset manifest: %w", err)
+	}
+	// A same-directory hard link publishes complete bytes without replacing an
+	// existing asset if another process claimed the destination during rendering.
+	if err := os.Link(staged, output); err != nil {
+		return Result{}, fmt.Errorf("publish video asset: %w", err)
+	}
+	if err := writeExclusive(output+".scene.json", data); err != nil {
+		os.Remove(output)
+		return Result{}, err
+	}
+	return result, nil
+}
+
+func fingerprint(path string) (string, int64, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return "", 0, fmt.Errorf("open rendered asset: %w", err)
+	}
+	defer file.Close()
+	hash := sha256.New()
+	size, err := io.Copy(hash, file)
+	if err != nil {
+		return "", 0, fmt.Errorf("fingerprint rendered asset: %w", err)
+	}
+	return hex.EncodeToString(hash.Sum(nil)), size, nil
+}
+
+func writeExclusive(path string, data []byte) error {
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("create asset manifest: %w", err)
+	}
+	_, writeErr := file.Write(data)
+	closeErr := file.Close()
+	if writeErr != nil {
+		os.Remove(path)
+		return fmt.Errorf("write asset manifest: %w", writeErr)
+	}
+	if closeErr != nil {
+		os.Remove(path)
+		return fmt.Errorf("close asset manifest: %w", closeErr)
+	}
+	return nil
+}

package/renderer/pipeline.go

@@ -0,0 +1,108 @@
+package sceneengine
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"sync"
+)
+
+type captureFunc func(ctx context.Context, frame int) ([]byte, error)
+
+type capturedFrame struct {
+	index int
+	bytes []byte
+	err   error
+}
+
+// Credits are returned only after ordered writes, bounding out-of-order buffers
+// even when an early frame is substantially slower than every later frame.
+func streamFrames(ctx context.Context, count int, captures []captureFunc, writer io.Writer, progress func(int)) error {
+	ctx, cancel := context.WithCancelCause(ctx)
+	defer cancel(nil)
+	window := len(captures) * 2
+	credits := make(chan struct{}, window)
+	jobs := make(chan int)
+	results := make(chan capturedFrame, len(captures))
+	var workers sync.WaitGroup
+	workers.Add(len(captures) + 1)
+	go scheduleFrames(ctx, count, credits, jobs, &workers)
+	for _, capture := range captures {
+		go captureFrames(ctx, capture, jobs, results, &workers)
+	}
+	defer workers.Wait()
+	defer cancel(context.Canceled)
+	pending := make(map[int][]byte)
+	next := 0
+	for next < count {
+		select {
+		case <-ctx.Done():
+			return context.Cause(ctx)
+		case result := <-results:
+			if result.err != nil {
+				return result.err
+			}
+			pending[result.index] = result.bytes
+			for {
+				frame, available := pending[next]
+				if !available {
+					break
+				}
+				written, err := writer.Write(frame)
+				if err != nil {
+					return fmt.Errorf("write frame %d to encoder: %w", next, err)
+				}
+				if written != len(frame) {
+					return fmt.Errorf("write frame %d to encoder: %w", next, io.ErrShortWrite)
+				}
+				delete(pending, next)
+				<-credits
+				next++
+				if progress != nil {
+					progress(next)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func scheduleFrames(ctx context.Context, count int, credits chan<- struct{}, jobs chan<- int, workers *sync.WaitGroup) {
+	defer workers.Done()
+	defer close(jobs)
+	for index := range count {
+		select {
+		case <-ctx.Done():
+			return
+		case credits <- struct{}{}:
+		}
+		select {
+		case <-ctx.Done():
+			return
+		case jobs <- index:
+		}
+	}
+}
+
+func captureFrames(ctx context.Context, capture captureFunc, jobs <-chan int, results chan<- capturedFrame, workers *sync.WaitGroup) {
+	defer workers.Done()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case index, available := <-jobs:
+			if !available {
+				return
+			}
+			buffer, err := capture(ctx, index)
+			select {
+			case <-ctx.Done():
+				return
+			case results <- capturedFrame{index: index, bytes: buffer, err: err}:
+			}
+			if err != nil {
+				return
+			}
+		}
+	}
+}

package/renderer/pipeline_test.go

@@ -0,0 +1,108 @@
+package sceneengine
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+func TestStreamFramesOrdersConcurrentResults(t *testing.T) {
+	capture := func(ctx context.Context, index int) ([]byte, error) {
+		if index%3 == 0 {
+			time.Sleep(5 * time.Millisecond)
+		}
+		return []byte(fmt.Sprintf("%02d|", index)), nil
+	}
+	var output bytes.Buffer
+	var progress []int
+	err := streamFrames(context.Background(), 30, []captureFunc{capture, capture, capture}, &output, func(written int) { progress = append(progress, written) })
+	if err != nil {
+		t.Fatal(err)
+	}
+	var expected bytes.Buffer
+	for index := 0; index < 30; index++ {
+		fmt.Fprintf(&expected, "%02d|", index)
+	}
+	if output.String() != expected.String() {
+		t.Fatalf("frames are out of order: %s", output.String())
+	}
+	if len(progress) != 30 || progress[29] != 30 {
+		t.Fatalf("invalid progress: %v", progress)
+	}
+}
+
+func TestStreamFramesBoundsReorderingWindow(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+	release := make(chan struct{})
+	var started atomic.Int64
+	capture := func(ctx context.Context, index int) ([]byte, error) {
+		started.Add(1)
+		if index == 0 {
+			select {
+			case <-release:
+			case <-ctx.Done():
+				return nil, ctx.Err()
+			}
+		}
+		return []byte{byte(index)}, nil
+	}
+	done := make(chan error, 1)
+	go func() { done <- streamFrames(ctx, 100, []captureFunc{capture, capture}, io.Discard, nil) }()
+	deadline := time.Now().Add(time.Second)
+	for started.Load() < 4 && time.Now().Before(deadline) {
+		time.Sleep(time.Millisecond)
+	}
+	time.Sleep(15 * time.Millisecond)
+	if value := started.Load(); value != 4 {
+		t.Errorf("expected window of four frames, got %d", value)
+	}
+	close(release)
+	if err := <-done; err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestStreamFramesCancelsOtherWorkersOnFailure(t *testing.T) {
+	expected := errors.New("broken frame")
+	blocked := make(chan struct{})
+	capture := func(ctx context.Context, index int) ([]byte, error) {
+		if index == 0 {
+			<-blocked
+			return nil, expected
+		}
+		close(blocked)
+		<-ctx.Done()
+		return nil, ctx.Err()
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	if err := streamFrames(ctx, 10, []captureFunc{capture, capture}, io.Discard, nil); !errors.Is(err, expected) {
+		t.Fatalf("expected capture failure, got %v", err)
+	}
+}
+
+func TestStreamFramesHonorsCancellation(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	capture := func(ctx context.Context, _ int) ([]byte, error) { cancel(); <-ctx.Done(); return nil, ctx.Err() }
+	if err := streamFrames(ctx, 10, []captureFunc{capture}, io.Discard, nil); !errors.Is(err, context.Canceled) {
+		t.Fatalf("expected cancellation, got %v", err)
+	}
+}
+
+type shortWriter struct{}
+
+func (shortWriter) Write(buffer []byte) (int, error) { return len(buffer) - 1, nil }
+
+func TestStreamFramesRejectsTruncatedWrites(t *testing.T) {
+	capture := func(context.Context, int) ([]byte, error) { return []byte("frame"), nil }
+	err := streamFrames(context.Background(), 2, []captureFunc{capture}, shortWriter{}, nil)
+	if !errors.Is(err, io.ErrShortWrite) {
+		t.Fatalf("expected a truncated-write error, got %v", err)
+	}
+}

package/renderer/render.go

@@ -0,0 +1,141 @@
+package sceneengine
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Render publishes an asset only after its complete video/audio encoding succeeds.
+func (r *Renderer) Render(ctx context.Context, request Request, output string) (result Result, renderErr error) {
+	if err := request.Validate(); err != nil {
+		return Result{}, err
+	}
+	codec, err := outputCodec(output, request.Config.Transparent)
+	if err != nil {
+		return Result{}, err
+	}
+	select {
+	case r.lease <- struct{}{}:
+		defer func() { <-r.lease }()
+	default:
+		return Result{}, fmt.Errorf("renderer is busy")
+	}
+	defer func() { renderErr = r.browserLog.wrap(renderErr) }()
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	stop := context.AfterFunc(r.browser, cancel)
+	defer stop()
+	started := time.Now()
+	staged, err := stageOutput(output)
+	if err != nil {
+		return Result{}, err
+	}
+	defer os.Remove(staged)
+	workers, err := r.loadWorkers(ctx, request)
+	if err != nil {
+		return Result{}, err
+	}
+	defer closeWorkers(workers)
+	metrics := RenderMetrics{Workers: len(workers), Load: time.Since(started)}
+	process, err := startEncoder(ctx, r.options, request, codec, staged)
+	if err != nil {
+		return Result{}, err
+	}
+	captures := make([]captureFunc, len(workers))
+	for index, worker := range workers {
+		captures[index] = worker.capture
+	}
+	streamStarted := time.Now()
+	err = streamFrames(ctx, request.Config.DurationInFrames, captures, process.input, func(written int) {
+		if r.options.Progress != nil {
+			r.options.Progress(Progress{WrittenFrames: written, TotalFrames: request.Config.DurationInFrames, Elapsed: time.Since(started)})
+		}
+	})
+	metrics.CaptureAndEncode = time.Since(streamStarted)
+	if err != nil {
+		cancel()
+		encodingErr := process.finish()
+		if encodingErr != nil {
+			return Result{}, fmt.Errorf("%w; encoder: %v", err, encodingErr)
+		}
+		return Result{}, err
+	}
+	drainStarted := time.Now()
+	if err := process.finish(); err != nil {
+		return Result{}, err
+	}
+	metrics.EncoderDrain = time.Since(drainStarted)
+	for _, worker := range workers {
+		metrics.SeekWorkerTime += worker.seekTime
+		metrics.CaptureWorkerTime += worker.captureTime
+	}
+	if err := ctx.Err(); err != nil {
+		return Result{}, err
+	}
+	return publishOutput(staged, output, request, workers[0].manifest, codec, time.Since(started), metrics)
+}
+
+func outputCodec(output string, transparent bool) (Codec, error) {
+	switch strings.ToLower(filepath.Ext(output)) {
+	case ".mp4":
+		if transparent {
+			return "", fmt.Errorf("transparent output requires .webm (VP9), not MP4")
+		}
+		return H264, nil
+	case ".webm":
+		return VP9, nil
+	default:
+		return "", fmt.Errorf("output extension must be .mp4 or .webm")
+	}
+}
+
+func (r *Renderer) loadWorkers(ctx context.Context, request Request) ([]*frameWorker, error) {
+	count := min(r.options.Concurrency, request.Config.DurationInFrames)
+	workers := make([]*frameWorker, count)
+	loadCtx, cancel := context.WithCancelCause(ctx)
+	var loading sync.WaitGroup
+	for index := range count {
+		loading.Go(func() {
+			worker, err := r.newWorker(loadCtx, request)
+			if err != nil {
+				cancel(fmt.Errorf("initialize worker %d: %w", index, err))
+				return
+			}
+			workers[index] = worker
+		})
+	}
+	loading.Wait()
+	if err := context.Cause(loadCtx); err != nil {
+		closeWorkers(workers)
+		cancel(err)
+		return nil, err
+	}
+	for _, worker := range workers[1:] {
+		if !reflect.DeepEqual(worker.manifest, workers[0].manifest) {
+			closeWorkers(workers)
+			cancel(context.Canceled)
+			return nil, fmt.Errorf("scene manifests differ between workers")
+		}
+	}
+	// Keep successful tabs alive until the job releases its workers.
+	closeFirst := workers[0].close
+	workers[0].close = func() {
+		cancel(context.Canceled)
+		closeFirst()
+	}
+	return workers, nil
+}
+
+func closeWorkers(workers []*frameWorker) {
+	for _, worker := range workers {
+		if worker != nil {
+			worker.close()
+		}
+	}
+}

package/renderer/request.go

@@ -0,0 +1,140 @@
+package sceneengine
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math"
+	"net/url"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	// Embedded originals: four 5 MiB images and two 20 MiB videos plus base64 expansion.
+	MaxRequestBytes    = 96 << 20
+	maxDimension       = 8192
+	maxFPS             = 240
+	maxFrames          = 1_000_000
+	maxAudioTracks     = 64
+	maxVolume          = 4
+	maxDurationSeconds = 24 * 60 * 60
+)
+
+// DecodeRequest rejects unknown fields, trailing documents and oversized input.
+func DecodeRequest(reader io.Reader) (Request, error) {
+	data, err := io.ReadAll(io.LimitReader(reader, MaxRequestBytes+1))
+	if err != nil {
+		return Request{}, fmt.Errorf("read scene request: %w", err)
+	}
+	if len(data) > MaxRequestBytes {
+		return Request{}, fmt.Errorf("scene request exceeds %d bytes", MaxRequestBytes)
+	}
+	var request Request
+	if bytes.HasPrefix(bytes.TrimSpace(data), []byte("{")) {
+		decoder := json.NewDecoder(bytes.NewReader(data))
+		decoder.DisallowUnknownFields()
+		if err := decoder.Decode(&request); err != nil {
+			return request, fmt.Errorf("decode scene JSON: %w", err)
+		}
+		if err := decoder.Decode(new(any)); err != io.EOF {
+			return request, fmt.Errorf("scene JSON must contain one document")
+		}
+	} else {
+		decoder := yaml.NewDecoder(bytes.NewReader(data))
+		decoder.KnownFields(true)
+		if err := decoder.Decode(&request); err != nil {
+			return request, fmt.Errorf("decode scene YAML: %w", err)
+		}
+		if err := decoder.Decode(new(any)); err != io.EOF {
+			return request, fmt.Errorf("scene YAML must contain one document")
+		}
+	}
+	if _, err := request.browserPayload(); err != nil {
+		return request, fmt.Errorf("props must contain JSON-compatible values: %w", err)
+	}
+	return request, nil
+}
+
+func (r Request) Validate() error {
+	if r.Version != ProtocolVersion {
+		return fmt.Errorf("unsupported scene protocol version %d", r.Version)
+	}
+	if strings.TrimSpace(r.SceneID) == "" {
+		return fmt.Errorf("sceneId is required")
+	}
+	if _, err := parseOrigin(r.URL); err != nil {
+		return fmt.Errorf("scene URL: %w", err)
+	}
+	if err := r.Config.validate(); err != nil {
+		return err
+	}
+	if len(r.Audio) > maxAudioTracks {
+		return fmt.Errorf("at most %d audio tracks are supported", maxAudioTracks)
+	}
+	for index, track := range r.Audio {
+		if err := track.validate(r.Config.Duration()); err != nil {
+			return fmt.Errorf("audio[%d]: %w", index, err)
+		}
+	}
+	if _, err := r.browserPayload(); err != nil {
+		return fmt.Errorf("serialize scene props: %w", err)
+	}
+	return nil
+}
+
+func (c Config) validate() error {
+	if c.Width <= 0 || c.Height <= 0 || c.Width > maxDimension || c.Height > maxDimension {
+		return fmt.Errorf("width and height must be between 1 and %d", maxDimension)
+	}
+	if c.Width%2 != 0 || c.Height%2 != 0 {
+		return fmt.Errorf("video width and height must be even")
+	}
+	if !finite(c.FPS) || c.FPS <= 0 || c.FPS > maxFPS {
+		return fmt.Errorf("fps must be between 0 and %d", maxFPS)
+	}
+	if c.DurationInFrames <= 0 || c.DurationInFrames > maxFrames {
+		return fmt.Errorf("durationInFrames must be between 1 and %d", maxFrames)
+	}
+	if !finite(c.Duration()) || c.Duration() > maxDurationSeconds {
+		return fmt.Errorf("scene duration must not exceed %d seconds", maxDurationSeconds)
+	}
+	if !finite(c.CaptionSafeBottom) || c.CaptionSafeBottom < 0 || c.CaptionSafeBottom > 0.5 {
+		return fmt.Errorf("captionSafeBottom must be between 0 and 0.5")
+	}
+	return nil
+}
+
+func (a AudioTrack) validate(totalDuration float64) error {
+	if strings.TrimSpace(a.File) == "" {
+		return fmt.Errorf("file is required")
+	}
+	if !finite(a.Start) || a.Start < 0 || a.Start >= totalDuration {
+		return fmt.Errorf("start must fall inside the composition")
+	}
+	if !finite(a.From) || a.From < 0 {
+		return fmt.Errorf("from must be nonnegative")
+	}
+	if !finite(a.Duration) || a.Duration <= 0 {
+		return fmt.Errorf("duration must be positive")
+	}
+	if a.Volume != nil && (!finite(*a.Volume) || *a.Volume < 0 || *a.Volume > maxVolume) {
+		return fmt.Errorf("volume must be between 0 and %d", maxVolume)
+	}
+	return nil
+}
+
+func finite(value float64) bool { return !math.IsNaN(value) && !math.IsInf(value, 0) }
+
+func parseOrigin(raw string) (string, error) {
+	parsed, err := url.Parse(raw)
+	if err != nil {
+		return "", err
+	}
+	if (parsed.Scheme != "http" && parsed.Scheme != "https") || parsed.Host == "" || parsed.User != nil {
+		return "", fmt.Errorf("expected an absolute HTTP(S) URL without credentials")
+	}
+	return strings.ToLower(parsed.Scheme + "://" + parsed.Host), nil
+}

package/renderer/request_test.go

@@ -0,0 +1,94 @@
+package sceneengine
+
+import (
+	"math"
+	"strings"
+	"testing"
+)
+
+func fixtureRequest() Request {
+	return Request{Version: 1, URL: "http://127.0.0.1:5178/scene.html", SceneID: "intro", Config: Config{Width: 640, Height: 360, FPS: 30, DurationInFrames: 90}}
+}
+
+func TestDecodeRequestRejectsAmbiguousInput(t *testing.T) {
+	for _, input := range []string{
+		`{"version":1,"unexpected":true}`,
+		`{"version":1} {"version":1}`,
+		"version: 1\n---\nversion: 1",
+		"version: 1\nversion: 2",
+		"version: 1\nunexpected: true",
+	} {
+		if _, err := DecodeRequest(strings.NewReader(input)); err == nil {
+			t.Errorf("accepted ambiguous request %q", input)
+		}
+	}
+}
+
+func TestDecodeYAMLPropsAreJSONCompatible(t *testing.T) {
+	request, err := DecodeRequest(strings.NewReader("version: 1\nprops:\n  title: Example\n  items: [1, two]\n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := request.browserPayload(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRequestValidation(t *testing.T) {
+	cases := map[string]func(*Request){
+		"odd dimensions":       func(r *Request) { r.Config.Width = 641 },
+		"invalid fps":          func(r *Request) { r.Config.FPS = math.NaN() },
+		"overflow duration":    func(r *Request) { r.Config.FPS = math.SmallestNonzeroFloat64 },
+		"empty duration":       func(r *Request) { r.Config.DurationInFrames = 0 },
+		"file URL":             func(r *Request) { r.URL = "file:///secret" },
+		"credentials":          func(r *Request) { r.URL = "https://user:pass@example.com" },
+		"invalid audio":        func(r *Request) { r.Audio = []AudioTrack{{File: "a.wav", Start: -1, Duration: 1}} },
+		"invalid caption band": func(r *Request) { r.Config.CaptionSafeBottom = 0.7 },
+	}
+	for name, mutate := range cases {
+		t.Run(name, func(t *testing.T) {
+			request := fixtureRequest()
+			mutate(&request)
+			if err := request.Validate(); err == nil {
+				t.Fatal("accepted invalid request")
+			}
+		})
+	}
+	if err := fixtureRequest().Validate(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestCaptionSafeBandSurvivesYAMLAndBrowserPayload(t *testing.T) {
+	request, err := DecodeRequest(strings.NewReader("version: 1\nconfig:\n  width: 1920\n  height: 1080\n  fps: 30\n  durationInFrames: 30\n  captionSafeBottom: 0.24\n"))
+	if err != nil || request.Config.CaptionSafeBottom != 0.24 {
+		t.Fatal(request, err)
+	}
+	payload, err := request.browserPayload()
+	if err != nil || !strings.Contains(string(payload), `"captionSafeBottom":0.24`) {
+		t.Fatal(string(payload), err)
+	}
+}
+
+func TestResourceOrigins(t *testing.T) {
+	allowed := map[string]bool{"http://127.0.0.1:5178": true}
+	for _, request := range []string{"http://127.0.0.1:5178/font.woff2", "data:image/png;base64,AA==", "blob:http://127.0.0.1:5178/id"} {
+		if !allowRequest(request, allowed) {
+			t.Errorf("blocked %s", request)
+		}
+	}
+	for _, request := range []string{"http://127.0.0.1:8080/private", "file:///secret", "https://example.com/font.woff2", "http://127.0.0.1:5178@evil.test"} {
+		if allowRequest(request, allowed) {
+			t.Errorf("allowed %s", request)
+		}
+	}
+}
+
+func TestAlphaRequiresWebM(t *testing.T) {
+	if _, err := outputCodec("scene.mp4", true); err == nil {
+		t.Fatal("accepted alpha MP4")
+	}
+	if codec, err := outputCodec("scene.webm", true); err != nil || codec != VP9 {
+		t.Fatalf("expected VP9, got %s, %v", codec, err)
+	}
+}