core

type Config ¶

type Config struct {
	Device    DeviceConfig
	Network   NetworkConfig
	Transcode TranscodeConfig
	Resolver  resolve.Config

	// Whisper is the subtitle-transcription knob NewPlan reads to choose the
	// subtitle axis (Enable gates burn-in). Its type lives in the cgo-free
	// subtitle package, not the whisper transcriber, so this decision core carries
	// it without importing whisper's cgo. A device that never serves (or a disabled
	// transcriber) simply resolves to SubtitleOff.
	Whisper subtitle.Whisper
}

Config is the device-neutral configuration the planner and every stage share: the target device, network, transcode binary, source resolver, and the subtitle transcriber. It composes only domain types, so core imports no application state; the app config assembles this and hands it in.

type DeliveryMode ¶

type DeliveryMode int

DeliveryMode is how the renderer receives the stream bytes: it either fetches the source URL itself (pass-through) or castor produces a stream locally and serves it. This is the first axis of a Plan; the copy-vs-encode and subtitle decisions only ever apply on a served cast, so several stages gate on it.

const (
	// DeliverPassthrough hands the device the source URL and lets it pull the
	// bytes directly: no local ffmpeg, no served stream. Chosen only when the
	// renderer self-fetches AND already accepts the source container, so nothing
	// needs rewrapping.
	DeliverPassthrough DeliveryMode = iota
	// DeliverServe produces the stream locally (a remux or a transcode) and serves
	// it to the device. A push-only renderer always lands here (it never
	// self-fetches), as does a self-fetching renderer whose source container it
	// will not take.
	DeliverServe
)

func ResolveDelivery(caps media.Renderer, source *media.Stream) DeliveryMode

type DeviceConfig ¶

type DeviceConfig = device.Config

DeviceConfig is the device section, owned by the device package so this device-agnostic layer neither defines nor names any device family. Core reads only its generic Name/Type (for discovery) and forwards the whole value to device.Connect, which alone interprets any family-specific field.

type NetworkConfig ¶

type NetworkConfig struct {
	Timeout   time.Duration `yaml:"timeout" validate:"required"`
	Interface string        `yaml:"interface"`
}

type OpenParams ¶

type OpenParams struct {
	FFmpegPath string
	Opts       ffmpeg.EncodeOptions
	StartOpts  []ffmpeg.StartOption
	LocalIP    string
	WorkDir    string
	Format     media.FormatInfo
	// OnStarted, if set, runs immediately after the encoder starts (before the
	// server is fronted), so a caller can wire a concurrent consumer of a second
	// output pipe (the spool path follows -progress on proc.Extra) without that
	// coupling leaking into this package.
	OnStarted func(*ffmpeg.Process)
}

OpenParams are the device-blind inputs to open a delivery: the encoder to run and how its input/output is wired, where to serve from, and the format that selects the mechanism. Headers are filled by Serve from the device, not here.

type Plan ¶

type Plan struct {
	// Delivery is pass-through versus locally served.
	Delivery DeliveryMode
	// Subtitle is off versus burned-in.
	Subtitle SubtitleMode
	// OutputContentType is the MIME type the device is told it is fetching: the
	// container the local ffmpeg muxes on a served cast, taken from the renderer's
	// declared ServedContainer. A pass-through cast reads the source's own content
	// type and never consults this, so it is left empty there.
	OutputContentType string
}

Plan is the pure decision record for one cast: what the executor must do, derived from (source, renderer capabilities, config) with no I/O. It is the single hand-off between the decision layer (this package) and the mechanism layer (the stages that pull, transcode, and serve).

It fixes only the axes that need no probe. It deliberately carries no encode invocation: copy-vs-encode needs a ProbeInfo, and the probe that matters is unavailable at planning time. The served spool path probes its local spool (the source URL can be single-use) and the network remux path probes the source URL, each obtained only once its stage runs, so each served stage builds its own EncodeOptions from the right probe (ResolveVideo + ResolveAudio). Nothing about the encode lives on the Plan.

func NewPlan(source *media.Stream, caps media.Renderer, cfg Config) Plan

type Sink ¶

type Sink interface {
	URL() *url.URL
	Wait(ctx context.Context) error
}

Sink is a running local server fronting a produced stream for one cast: it exposes the URL the renderer fetches and blocks until the stream is fully delivered. Closing it is the opener's job (its teardown holds the concrete server), so the driver only ever needs these two. Both replay.Server and hlsserve.Server satisfy it unchanged.

type SubtitleMode ¶

type SubtitleMode int

SubtitleMode is the subtitle axis of a Plan. Stage 1 carries only the two modes today's code produces; a future SubtitleSidecar (a separately served caption track the device loads) is wired as a new enum value so the executor gains a branch without any reshuffle of the existing ones.

const (
	// SubtitleOff ships no subtitles: every pass-through cast, every served cast
	// with the transcriber disabled, and (this stage) every self-fetching renderer.
	SubtitleOff SubtitleMode = iota
	// SubtitleBurnIn transcribes the audio and draws the cues into the video
	// frames during the encode (whisper hardsubs). It forces a video re-encode
	// (drawtext needs decoded frames) and so is only reachable on a served cast.
	SubtitleBurnIn
)

func ResolveSubtitle(caps media.Renderer, cfg Config) SubtitleMode

type TranscodeConfig ¶

type TranscodeConfig struct {
	FFmpegPath string        `yaml:"ffmpeg_path" validate:"required"`
	RWTimeout  time.Duration `yaml:"rw_timeout" validate:"required"`
}

TranscodeConfig holds the small set of ffmpeg settings that aren't decided by the plan. Codec/bitrate/format choices are resolved from capabilities (see the Resolve* functions); only the binary path and the upstream I/O timeout, which no capability can determine, come from config.