@machinal/scenes 0.0.0-stage → 0.1.0

package/renderer/types.go

@@ -0,0 +1,113 @@
+package sceneengine
+
+import (
+	"encoding/json"
+	"time"
+)
+
+const ProtocolVersion = 1
+
+// Config uses frame indexes for duration and seconds only for FPS conversion.
+type Config struct {
+	Width             int     `json:"width" yaml:"width"`
+	Height            int     `json:"height" yaml:"height"`
+	FPS               float64 `json:"fps" yaml:"fps"`
+	DurationInFrames  int     `json:"durationInFrames" yaml:"durationInFrames"`
+	Transparent       bool    `json:"transparent,omitempty" yaml:"transparent,omitempty"`
+	CaptionSafeBottom float64 `json:"captionSafeBottom,omitempty" yaml:"captionSafeBottom,omitempty"`
+}
+
+func (c Config) Duration() float64 { return float64(c.DurationInFrames) / c.FPS }
+
+// AudioTrack describes a local source; the scene's browser never plays this audio.
+type AudioTrack struct {
+	File     string   `json:"file" yaml:"file"`
+	Start    float64  `json:"start" yaml:"start"`
+	From     float64  `json:"from,omitempty" yaml:"from,omitempty"`
+	Duration float64  `json:"duration" yaml:"duration"`
+	Volume   *float64 `json:"volume,omitempty" yaml:"volume,omitempty"`
+}
+
+// Request is a portable JSON/YAML render job. Relative audio paths are resolved by the CLI.
+type Request struct {
+	Version int            `json:"version" yaml:"version"`
+	URL     string         `json:"url" yaml:"url"`
+	SceneID string         `json:"sceneId" yaml:"sceneId"`
+	Seed    string         `json:"seed,omitempty" yaml:"seed,omitempty"`
+	Config  Config         `json:"config" yaml:"config"`
+	Props   map[string]any `json:"props,omitempty" yaml:"props,omitempty"`
+	Audio   []AudioTrack   `json:"audio,omitempty" yaml:"audio,omitempty"`
+}
+
+// Manifest records the resolved scene parameters reported by the browser runtime.
+type Manifest struct {
+	Version int            `json:"version"`
+	SceneID string         `json:"sceneId"`
+	Seed    string         `json:"seed"`
+	Config  Config         `json:"config"`
+	Props   map[string]any `json:"props"`
+}
+
+type Codec string
+
+const (
+	H264 Codec = "h264"
+	VP9  Codec = "vp9"
+)
+
+// Result is the asset boundary between this module and an application.
+type Result struct {
+	Version     int           `json:"version"`
+	File        string        `json:"file"`
+	SHA256      string        `json:"sha256"`
+	Size        int64         `json:"size"`
+	Duration    float64       `json:"duration"`
+	Width       int           `json:"width"`
+	Height      int           `json:"height"`
+	FPS         float64       `json:"fps"`
+	Frames      int           `json:"frames"`
+	HasAudio    bool          `json:"hasAudio"`
+	Transparent bool          `json:"transparent"`
+	Codec       Codec         `json:"codec"`
+	Scene       Manifest      `json:"scene"`
+	Elapsed     time.Duration `json:"elapsedNanoseconds"`
+	Metrics     RenderMetrics `json:"metrics"`
+}
+
+type RenderMetrics struct {
+	Workers           int           `json:"workers"`
+	Load              time.Duration `json:"loadNanoseconds"`
+	CaptureAndEncode  time.Duration `json:"captureAndEncodeNanoseconds"`
+	EncoderDrain      time.Duration `json:"encoderDrainNanoseconds"`
+	SeekWorkerTime    time.Duration `json:"seekWorkerNanoseconds"`
+	CaptureWorkerTime time.Duration `json:"captureWorkerNanoseconds"`
+}
+
+type Progress struct {
+	WrittenFrames int           `json:"writtenFrames"`
+	TotalFrames   int           `json:"totalFrames"`
+	Elapsed       time.Duration `json:"elapsedNanoseconds"`
+}
+
+// Options configures browser ownership and the bounded frame pipeline.
+type Options struct {
+	BrowserExecutable string
+	FFmpegExecutable  string
+	Concurrency       int
+	FrameTimeout      time.Duration
+	AllowedOrigins    []string
+	NoSandbox         bool
+	EnableGPU         bool
+	Lossless          bool
+	X264Preset        string
+	EncoderThreads    int
+	Progress          func(Progress)
+}
+
+func (r Request) browserPayload() ([]byte, error) {
+	props := r.Props
+	if props == nil {
+		props = map[string]any{}
+	}
+	return json.Marshal(Manifest{Version: r.Version, SceneID: r.SceneID, Seed: r.Seed, Config: r.Config, Props: props})
+}

package/renderer/worker.go

@@ -0,0 +1,110 @@
+package sceneengine
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/chromedp/cdproto/cdp"
+	"github.com/chromedp/cdproto/emulation"
+	"github.com/chromedp/cdproto/page"
+	"github.com/chromedp/chromedp"
+)
+
+type frameWorker struct {
+	ctx         context.Context
+	close       func()
+	request     Request
+	manifest    Manifest
+	options     Options
+	cancel      context.CancelFunc
+	seekTime    time.Duration
+	captureTime time.Duration
+}
+
+func (r *Renderer) newWorker(job context.Context, request Request) (*frameWorker, error) {
+	tab, cancel := chromedp.NewContext(r.browser)
+	stop := context.AfterFunc(job, cancel)
+	worker := &frameWorker{ctx: tab, close: func() { stop(); cancel() }, cancel: cancel, request: request, options: r.options}
+	// The first action owns the target's event loop, so it must use the tab's
+	// lifetime context rather than the short-lived page preparation context.
+	timeout := time.AfterFunc(r.options.FrameTimeout, cancel)
+	err := chromedp.Do(tab)
+	timeout.Stop()
+	if err != nil {
+		worker.close()
+		return nil, fmt.Errorf("create worker tab: %w", err)
+	}
+	if err := worker.load(); err != nil {
+		worker.close()
+		return nil, err
+	}
+	return worker, nil
+}
+
+func (w *frameWorker) load() error {
+	payload, err := w.request.browserPayload()
+	if err != nil {
+		return fmt.Errorf("serialize browser request: %w", err)
+	}
+	ctx, cancel := context.WithTimeout(w.ctx, w.options.FrameTimeout)
+	defer cancel()
+	err = chromedp.Do(ctx,
+		chromedp.EmulateViewport(int64(w.request.Config.Width), int64(w.request.Config.Height)),
+		chromedp.Func(func(ctx context.Context, target *chromedp.Target) error {
+			if !w.request.Config.Transparent {
+				return nil
+			}
+			// Explicit zero alpha is omitted by the generated protocol type.
+			return target.Call(ctx, emulation.SetDefaultBackgroundColorOverride.Method, map[string]any{"color": map[string]any{"r": 0, "g": 0, "b": 0, "a": 0}}, nil)
+		}),
+		restrictNetwork(w.ctx, w.request.URL, w.options.AllowedOrigins, w.cancel),
+		chromedp.Func(func(ctx context.Context, target *chromedp.Target) error {
+			_, err := cdp.Call(ctx, target, page.AddScriptToEvaluateOnNewDocument, page.AddScriptToEvaluateOnNewDocumentParams{Source: "window.__sceneRequest = " + string(payload) + ";"})
+			return err
+		}),
+		chromedp.Navigate(w.request.URL),
+		chromedp.Poll[chromedp.Void]("Boolean(window.__scene || window.__sceneError)", chromedp.WithPollingTimeout(w.options.FrameTimeout)),
+	)
+	if err != nil {
+		return fmt.Errorf("prepare scene page: %w", err)
+	}
+	w.manifest, err = chromedp.Run(ctx, chromedp.Evaluate[Manifest](`(async () => {
+   if (window.__sceneError) throw new Error(window.__sceneError);
+   if (window.__scene.version !== 1) throw new Error('Unsupported scene protocol');
+   await window.__scene.ready();
+   return window.__scene.manifest;
+  })()`, chromedp.EvalAwaitPromise))
+	if err != nil {
+		return fmt.Errorf("load scene %q: %w", w.request.SceneID, err)
+	}
+	if w.manifest.Version != ProtocolVersion || w.manifest.SceneID != w.request.SceneID || w.manifest.Config != w.request.Config {
+		return fmt.Errorf("scene manifest does not match the render request")
+	}
+	return nil
+}
+
+func (w *frameWorker) capture(job context.Context, frame int) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(w.ctx, w.options.FrameTimeout)
+	defer cancel()
+	stop := context.AfterFunc(job, cancel)
+	defer stop()
+	started := time.Now()
+	err := chromedp.Do(ctx, chromedp.Evaluate[chromedp.Void](fmt.Sprintf("window.__scene.seek(%d)", frame), chromedp.EvalAwaitPromise))
+	w.seekTime += time.Since(started)
+	if err != nil {
+		return nil, fmt.Errorf("seek frame %d: %w", frame, err)
+	}
+	started = time.Now()
+	buffer, err := chromedp.Run(ctx, func(ctx context.Context, target *chromedp.Target) ([]byte, error) {
+		beyondViewport, optimize := false, true
+		params := page.CaptureScreenshotParams{Format: page.CaptureScreenshotFormatPng, CaptureBeyondViewport: &beyondViewport, OptimizeForSpeed: &optimize}
+		result, err := cdp.Call(ctx, target, page.CaptureScreenshot, params)
+		return result.Data, err
+	})
+	w.captureTime += time.Since(started)
+	if err != nil {
+		return nil, fmt.Errorf("capture frame %d: %w", frame, err)
+	}
+	return buffer, nil
+}