Updated to v0.2.5.

Encoders now receive the codec being used, allowing them to adjust their flags accordingly. For example, the software encoder gates x264-specific parameters behind a codec check so that future encoders like libx265 or libsvtav1 can provide their own flags without conflict. Pixel format is now specified per variant with a stream specifier rather than globally, enabling codecs like AV1 to use 10-bit color for improved compression efficiency while H.264 variants continue using yuv420p.

config/defaults.go

@@ -93,6 +93,8 @@ func GetDefaults() Defaults {
 				VideoBitrate:       1200,
 				Framerate:          24,
 				CPUUsageLevel:      2,
+				VideoCodec:         "h264",
+				AudioCodec:         "aac",
 			},
 		},
 

core/core.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"fmt"
 	"os"
 	"path"
 	"path/filepath"
@@ -98,23 +99,53 @@ func createInitialOfflineState() error {
 // offline video stream state only.  No live stream HLS segments will continue to be
 // referenced.
 func transitionToOfflineVideoStreamContent() {
-	log.Traceln("Firing transcoder with offline stream state")
+	log.Traceln("Placing offline fMP4 content into HLS directories")
 
-	_transcoder := transcoder.NewTranscoder()
-	_transcoder.SetIdentifier("offline")
-	_transcoder.SetLatencyLevel(models.GetLatencyLevel(4))
-	_transcoder.SetIsEvent(true)
+	configRepository := configrepository.Get()
 
-	offlineFilePath, err := saveOfflineClipToDisk("offline-v2.ts")
+	offlineInitPath, offlineSegmentPath, err := saveOfflineFMP4ToDisk()
 	if err != nil {
-		log.Fatalln("unable to save offline clip:", err)
+		log.Fatalln("unable to save offline fMP4 files:", err)
 	}
 
-	_transcoder.SetInput(offlineFilePath)
-	go _transcoder.Start(false)
+	variants := configRepository.GetStreamOutputVariants()
+	if len(variants) == 0 {
+		// Ensure at least one variant directory exists.
+		variants = make([]models.StreamOutputVariant, 1)
+	}
+
+	for index := range variants {
+		variantDir := filepath.Join(config.HLSStoragePath, fmt.Sprintf("%d", index))
+		if err := os.MkdirAll(variantDir, 0o750); err != nil {
+			log.Errorln("unable to create variant directory:", err)
+			continue
+		}
+		makeVariantIndexOffline(index, offlineInitPath, offlineSegmentPath)
+	}
+
+	// Write the master playlist that points to each variant's playlist.
+	masterPlaylistPath := filepath.Join(config.HLSStoragePath, "stream.m3u8")
+	masterFile, err := os.Create(masterPlaylistPath) //nolint:gosec
+	if err != nil {
+		log.Errorln("unable to create master playlist:", err)
+	} else {
+		_, _ = masterFile.WriteString("#EXTM3U\n")
+		_, _ = masterFile.WriteString("#EXT-X-VERSION:7\n")
+		_, _ = masterFile.WriteString("#EXT-X-INDEPENDENT-SEGMENTS\n")
+		for index := range variants {
+			_, _ = fmt.Fprintf(masterFile, "#EXT-X-STREAM-INF:BANDWIDTH=0\n")
+			_, _ = fmt.Fprintf(masterFile, "%d/stream.m3u8\n", index)
+		}
+		if err := masterFile.Close(); err != nil {
+			log.Errorln("unable to close master playlist:", err)
+		}
+
+		// Notify the storage provider so it can rewrite variant URLs
+		// to absolute paths for S3 or remote serving endpoints.
+		_storage.MasterPlaylistWritten(masterPlaylistPath)
+	}
 
 	// Copy the logo to be the thumbnail
-	configRepository := configrepository.Get()
 	logo := configRepository.GetLogoPath()
 	dst := filepath.Join(config.TempDir, "thumbnail.jpg")
 	if err = utils.Copy(filepath.Join("data", logo), dst); err != nil {

core/offlineState.go

@@ -5,14 +5,13 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/grafov/m3u8"
 	"github.com/owncast/owncast/config"
 	"github.com/owncast/owncast/static"
 	"github.com/owncast/owncast/utils"
 	log "github.com/sirupsen/logrus"
 )
 
-func appendOfflineToVariantPlaylist(index int, playlistFilePath string) {
+func appendOfflineToVariantPlaylist(index int, playlistFilePath string, initFilename string, segmentFilename string) {
 	existingPlaylistContents, err := os.ReadFile(playlistFilePath) // nolint: gosec
 	if err != nil {
 		log.Debugln("unable to read existing playlist file", err)
@@ -34,9 +33,10 @@ func appendOfflineToVariantPlaylist(index int, playlistFilePath string) {
 
 	// Manually append the offline clip to the end of the media playlist.
 	_, _ = atomicWriteTmpPlaylistFile.WriteString("#EXT-X-DISCONTINUITY\n")
+	_, _ = fmt.Fprintf(atomicWriteTmpPlaylistFile, "#EXT-X-MAP:URI=\"%s\"\n", initFilename)
 	// If "offline" content gets changed then change the duration below
 	_, _ = atomicWriteTmpPlaylistFile.WriteString("#EXTINF:8.000000,\n")
-	_, _ = atomicWriteTmpPlaylistFile.WriteString("offline-v2.ts\n")
+	_, _ = fmt.Fprintf(atomicWriteTmpPlaylistFile, "%s\n", segmentFilename)
 	_, _ = atomicWriteTmpPlaylistFile.WriteString("#EXT-X-ENDLIST\n")
 
 	if err := atomicWriteTmpPlaylistFile.Close(); err != nil {
@@ -48,61 +48,89 @@ func appendOfflineToVariantPlaylist(index int, playlistFilePath string) {
 	}
 }
 
-func makeVariantIndexOffline(index int, offlineFilePath string, offlineFilename string) {
-	playlistFilePath := fmt.Sprintf(filepath.Join(config.HLSStoragePath, "%d/stream.m3u8"), index)
-	segmentFilePath := fmt.Sprintf(filepath.Join(config.HLSStoragePath, "%d/%s"), index, offlineFilename)
+func makeVariantIndexOffline(index int, offlineInitPath string, offlineSegmentPath string) {
+	variantDir := filepath.Join(config.HLSStoragePath, fmt.Sprintf("%d", index))
+	playlistFilePath := filepath.Join(variantDir, "stream.m3u8")
 
-	if err := utils.Copy(offlineFilePath, segmentFilePath); err != nil {
+	initDest := filepath.Join(variantDir, "offline-init.mp4")
+	segmentDest := filepath.Join(variantDir, "offline-v2.m4s")
+
+	if err := utils.Copy(offlineInitPath, initDest); err != nil {
+		log.Warnln(err)
+		return
+	}
+
+	if _, err := _storage.Save(initDest, 0); err != nil {
 		log.Warnln(err)
 	}
 
-	if _, err := _storage.Save(segmentFilePath, 0); err != nil {
+	if err := utils.Copy(offlineSegmentPath, segmentDest); err != nil {
+		log.Warnln(err)
+		return
+	}
+
+	if _, err := _storage.Save(segmentDest, 0); err != nil {
 		log.Warnln(err)
 	}
 
 	if utils.DoesFileExists(playlistFilePath) {
-		appendOfflineToVariantPlaylist(index, playlistFilePath)
+		appendOfflineToVariantPlaylist(index, playlistFilePath, "offline-init.mp4", "offline-v2.m4s")
 	} else {
-		createEmptyOfflinePlaylist(playlistFilePath, offlineFilename)
+		createEmptyOfflinePlaylist(playlistFilePath, "offline-init.mp4", "offline-v2.m4s")
 	}
 	if _, err := _storage.Save(playlistFilePath, 0); err != nil {
 		log.Warnln(err)
 	}
 }
 
-func createEmptyOfflinePlaylist(playlistFilePath string, offlineFilename string) {
-	p, err := m3u8.NewMediaPlaylist(1, 1)
-	if err != nil {
-		log.Errorln(err)
-	}
-
-	// If "offline" content gets changed then change the duration below
-	if err := p.Append(offlineFilename, 8.0, ""); err != nil {
-		log.Errorln(err)
-	}
-
-	p.Close()
+func createEmptyOfflinePlaylist(playlistFilePath string, initFilename string, segmentFilename string) {
 	f, err := os.Create(playlistFilePath) //nolint:gosec
 	if err != nil {
 		log.Errorln(err)
+		return
 	}
 	defer f.Close()
-	if _, err := f.Write(p.Encode().Bytes()); err != nil {
-		log.Errorln(err)
-	}
+
+	_, _ = f.WriteString("#EXTM3U\n")
+	_, _ = f.WriteString("#EXT-X-VERSION:7\n")
+	_, _ = f.WriteString("#EXT-X-TARGETDURATION:8\n")
+	_, _ = fmt.Fprintf(f, "#EXT-X-MAP:URI=\"%s\"\n", initFilename)
+	// If "offline" content gets changed then change the duration below
+	_, _ = f.WriteString("#EXTINF:8.000000,\n")
+	_, _ = fmt.Fprintf(f, "%s\n", segmentFilename)
+	_, _ = f.WriteString("#EXT-X-ENDLIST\n")
 }
 
-func saveOfflineClipToDisk(offlineFilename string) (string, error) {
-	offlineFileData := static.GetOfflineSegment()
-	offlineTmpFile, err := os.CreateTemp(config.TempDir, offlineFilename)
+func saveOfflineFMP4ToDisk() (initPath string, segmentPath string, err error) {
+	initData := static.GetOfflineInitSegment()
+	initTmp, err := os.CreateTemp(config.TempDir, "offline-init-*.mp4")
 	if err != nil {
-		log.Errorln("unable to create temp file for offline video segment", err)
+		return "", "", fmt.Errorf("unable to create temp file for offline init segment: %s", err)
 	}
 
-	if _, err = offlineTmpFile.Write(offlineFileData); err != nil {
-		return "", fmt.Errorf("unable to write offline segment to disk: %s", err)
+	if _, err = initTmp.Write(initData); err != nil {
+		return "", "", fmt.Errorf("unable to write offline init segment to disk: %s", err)
 	}
 
-	offlineFilePath := offlineTmpFile.Name()
-	return filepath.Abs(offlineFilePath)
+	if err := initTmp.Close(); err != nil {
+		return "", "", fmt.Errorf("unable to close offline init segment: %s", err)
+	}
+	initPath, _ = filepath.Abs(initTmp.Name())
+
+	segData := static.GetOfflineMediaSegment()
+	segTmp, err := os.CreateTemp(config.TempDir, "offline-v2-*.m4s")
+	if err != nil {
+		return "", "", fmt.Errorf("unable to create temp file for offline media segment: %s", err)
+	}
+
+	if _, err = segTmp.Write(segData); err != nil {
+		return "", "", fmt.Errorf("unable to write offline media segment to disk: %s", err)
+	}
+
+	if err := segTmp.Close(); err != nil {
+		return "", "", fmt.Errorf("unable to close offline media segment: %s", err)
+	}
+	segmentPath, _ = filepath.Abs(segTmp.Name())
+
+	return initPath, segmentPath, nil
 }

core/storageproviders/local.go

@@ -82,7 +82,7 @@ func getAllFilesRecursive(baseDirectory string) (map[string][]os.FileInfo, error
 			directory = info.Name()
 		}
 
-		if filepath.Ext(info.Name()) == ".ts" {
+		if filepath.Ext(info.Name()) == ".m4s" {
 			files[directory] = append(files[directory], info)
 		}
 

core/storageproviders/s3Storage.go

@@ -317,7 +317,7 @@ func (s *S3Storage) retrieveAllVideoSegments() ([]s3object, error) {
 	err := s.s3Client.ListObjectsPages(allObjectsListRequest,
 		func(page *s3.ListObjectsOutput, lastPage bool) bool {
 			for _, item := range page.Contents {
-				if strings.HasSuffix(*item.Key, ".ts") {
+				if strings.HasSuffix(*item.Key, ".m4s") {
 					allObjects = append(allObjects, s3object{
 						key:          *item.Key,
 						lastModified: *item.LastModified,

core/streamState.go

@@ -96,9 +96,7 @@ func SetStreamAsDisconnected() {
 	_stats.LastConnectTime = nil
 	_broadcaster = nil
 
-	offlineFilename := "offline-v2.ts"
-
-	offlineFilePath, err := saveOfflineClipToDisk(offlineFilename)
+	offlineInitPath, offlineSegmentPath, err := saveOfflineFMP4ToDisk()
 	if err != nil {
 		log.Errorln(err)
 		return
@@ -122,7 +120,7 @@ func SetStreamAsDisconnected() {
 	}
 
 	for index := range _currentBroadcast.OutputSettings {
-		makeVariantIndexOffline(index, offlineFilePath, offlineFilename)
+		makeVariantIndexOffline(index, offlineInitPath, offlineSegmentPath)
 	}
 
 	StartOfflineCleanupTimer()

core/transcoder/audiocodec.go

@@ -0,0 +1,42 @@
+package transcoder
+
+const audioCodecAAC = "aac"
+
+// aacFFmpegEncoder happens to match audioCodecAAC, but represents the ffmpeg
+// encoder name, which could be "libfdk_aac" or another AAC encoder instead.
+const aacFFmpegEncoder = "aac"
+
+// AudioCodec represents an audio compression format (e.g., AAC, Opus).
+type AudioCodec interface {
+	Name() string
+	DisplayName() string
+	FFmpegEncoderName() string
+}
+
+// AACCodec implements AudioCodec for AAC audio.
+type AACCodec struct{}
+
+func (c *AACCodec) Name() string {
+	return audioCodecAAC
+}
+
+func (c *AACCodec) DisplayName() string {
+	return "AAC"
+}
+
+// FFmpegEncoderName returns the ffmpeg encoder to use. We use the built-in
+// "aac" encoder rather than "libfdk_aac" since it is universally available.
+func (c *AACCodec) FFmpegEncoderName() string {
+	return aacFFmpegEncoder
+}
+
+var audioCodecRegistry = map[string]AudioCodec{
+	audioCodecAAC: &AACCodec{},
+}
+
+func getAudioCodec(name string) AudioCodec {
+	if codec, ok := audioCodecRegistry[name]; ok {
+		return codec
+	}
+	return &AACCodec{}
+}

core/transcoder/codecs.go

@@ -1,549 +0,0 @@
-//nolint:goconst
-
-package transcoder
-
-import (
-	"fmt"
-	"os/exec"
-	"strings"
-
-	log "github.com/sirupsen/logrus"
-)
-
-// Codec represents a supported codec on the system.
-type Codec interface {
-	Name() string
-	DisplayName() string
-	GlobalFlags() []string
-	PixelFormat() string
-	Scaler() string
-	ExtraArguments() []string
-	ExtraFilters() string
-	VariantFlags(v *HLSVariant) []string
-	GetPresetForLevel(l int) string
-}
-
-var supportedCodecs = map[string]string{
-	(&Libx264Codec{}).Name():      "libx264",
-	(&OmxCodec{}).Name():          "omx",
-	(&VaapiCodec{}).Name():        "vaapi",
-	(&QuicksyncCodec{}).Name():    "qsv",
-	(&NvencCodec{}).Name():        "NVIDIA nvenc",
-	(&VideoToolboxCodec{}).Name(): "videotoolbox",
-}
-
-// Libx264Codec represents an instance of the Libx264 Codec.
-type Libx264Codec struct{}
-
-// Name returns the codec name.
-func (c *Libx264Codec) Name() string {
-	return "libx264"
-}
-
-// DisplayName returns the human readable name of the codec.
-func (c *Libx264Codec) DisplayName() string {
-	return "x264"
-}
-
-// GlobalFlags are the global flags used with this codec in the transcoder.
-func (c *Libx264Codec) GlobalFlags() []string {
-	return nil
-}
-
-// PixelFormat is the pixel format required for this codec.
-func (c *Libx264Codec) PixelFormat() string {
-	return "yuv420p" //nolint:goconst
-}
-
-// Scaler is the scaler used for resizing the video in the transcoder.
-func (c *Libx264Codec) Scaler() string {
-	return ""
-}
-
-// ExtraArguments are the extra arguments used with this codec in the transcoder.
-func (c *Libx264Codec) ExtraArguments() []string {
-	return []string{
-		"-tune", "zerolatency", // Option used for good for fast encoding and low-latency streaming (always includes iframes in each segment)
-	}
-}
-
-// ExtraFilters are the extra filters required for this codec in the transcoder.
-func (c *Libx264Codec) ExtraFilters() string {
-	return ""
-}
-
-// VariantFlags returns a string representing a single variant processed by this codec.
-func (c *Libx264Codec) VariantFlags(v *HLSVariant) []string {
-	return []string{
-		fmt.Sprintf("-x264-params:v:%d", v.index),
-		"scenecut=0:open_gop=0", // How often the encoder checks the bitrate in order to meet average/max values
-		fmt.Sprintf("-bufsize:v:%d", v.index), fmt.Sprintf("%dk", v.getBufferSize()),
-		fmt.Sprintf("-profile:v:%d", v.index), "high", // Encoding profile
-	}
-}
-
-// GetPresetForLevel returns the string preset for this codec given an integer level.
-func (c *Libx264Codec) GetPresetForLevel(l int) string {
-	presetMapping := map[int]string{
-		0: "ultrafast",
-		1: "superfast",
-		2: "veryfast",
-		3: "faster",
-		4: "fast",
-	}
-
-	preset, ok := presetMapping[l]
-	if !ok {
-		defaultPreset := presetMapping[1]
-		log.Errorf("Invalid level for x264 preset %d, defaulting to %s", l, defaultPreset)
-		return defaultPreset
-	}
-
-	return preset
-}
-
-// OmxCodec represents an instance of the Omx codec.
-type OmxCodec struct{}
-
-// Name returns the codec name.
-func (c *OmxCodec) Name() string {
-	return "h264_omx"
-}
-
-// DisplayName returns the human readable name of the codec.
-func (c *OmxCodec) DisplayName() string {
-	return "OpenMAX (omx)"
-}
-
-// GlobalFlags are the global flags used with this codec in the transcoder.
-func (c *OmxCodec) GlobalFlags() []string {
-	return nil
-}
-
-// PixelFormat is the pixel format required for this codec.
-func (c *OmxCodec) PixelFormat() string {
-	return "yuv420p"
-}
-
-// Scaler is the scaler used for resizing the video in the transcoder.
-func (c *OmxCodec) Scaler() string {
-	return ""
-}
-
-// ExtraArguments are the extra arguments used with this codec in the transcoder.
-func (c *OmxCodec) ExtraArguments() []string {
-	return []string{
-		"-tune", "zerolatency", // Option used for good for fast encoding and low-latency streaming (always includes iframes in each segment)
-	}
-}
-
-// ExtraFilters are the extra filters required for this codec in the transcoder.
-func (c *OmxCodec) ExtraFilters() string {
-	return ""
-}
-
-// VariantFlags returns a string representing a single variant processed by this codec.
-func (c *OmxCodec) VariantFlags(v *HLSVariant) []string {
-	return nil
-}
-
-// GetPresetForLevel returns the string preset for this codec given an integer level.
-func (c *OmxCodec) GetPresetForLevel(l int) string {
-	presetMapping := map[int]string{
-		0: "ultrafast",
-		1: "superfast",
-		2: "veryfast",
-		3: "faster",
-		4: "fast",
-	}
-
-	preset, ok := presetMapping[l]
-	if !ok {
-		defaultPreset := presetMapping[1]
-		log.Errorf("Invalid level for omx preset %d, defaulting to %s", l, defaultPreset)
-		return defaultPreset
-	}
-
-	return preset
-}
-
-// VaapiCodec represents an instance of the Vaapi codec.
-type VaapiCodec struct{}
-
-// Name returns the codec name.
-func (c *VaapiCodec) Name() string {
-	return "h264_vaapi"
-}
-
-// DisplayName returns the human readable name of the codec.
-func (c *VaapiCodec) DisplayName() string {
-	return "VA-API"
-}
-
-// GlobalFlags are the global flags used with this codec in the transcoder.
-func (c *VaapiCodec) GlobalFlags() []string {
-	flags := []string{
-		"-hwaccel", "vaapi",
-		"-hwaccel_output_format", "vaapi",
-		"-vaapi_device", "/dev/dri/renderD128",
-	}
-
-	return flags
-}
-
-// PixelFormat is the pixel format required for this codec.
-func (c *VaapiCodec) PixelFormat() string {
-	return "vaapi"
-}
-
-// Scaler is the scaler used for resizing the video in the transcoder.
-func (c *VaapiCodec) Scaler() string {
-	return "scale_vaapi"
-}
-
-// ExtraFilters are the extra filters required for this codec in the transcoder.
-func (c *VaapiCodec) ExtraFilters() string {
-	return "hwupload=extra_hw_frames=64,format=vaapi"
-}
-
-// ExtraArguments are the extra arguments used with this codec in the transcoder.
-func (c *VaapiCodec) ExtraArguments() []string {
-	return nil
-}
-
-// VariantFlags returns a string representing a single variant processed by this codec.
-func (c *VaapiCodec) VariantFlags(v *HLSVariant) []string {
-	return nil
-}
-
-// GetPresetForLevel returns the string preset for this codec given an integer level.
-func (c *VaapiCodec) GetPresetForLevel(l int) string {
-	presetMapping := map[int]string{
-		0: "ultrafast",
-		1: "superfast",
-		2: "veryfast",
-		3: "faster",
-		4: "fast",
-	}
-
-	preset, ok := presetMapping[l]
-	if !ok {
-		defaultPreset := presetMapping[1]
-		log.Errorf("Invalid level for vaapi preset %d, defaulting to %s", l, defaultPreset)
-		return defaultPreset
-	}
-
-	return preset
-}
-
-// NvencCodec represents an instance of the Nvenc Codec.
-type NvencCodec struct{}
-
-// Name returns the codec name.
-func (c *NvencCodec) Name() string {
-	return "h264_nvenc"
-}
-
-// DisplayName returns the human readable name of the codec.
-func (c *NvencCodec) DisplayName() string {
-	return "nvidia nvenc"
-}
-
-// GlobalFlags are the global flags used with this codec in the transcoder.
-func (c *NvencCodec) GlobalFlags() []string {
-	flags := []string{
-		"-hwaccel", "cuda",
-	}
-
-	return flags
-}
-
-// PixelFormat is the pixel format required for this codec.
-func (c *NvencCodec) PixelFormat() string {
-	return "yuv420p"
-}
-
-// Scaler is the scaler used for resizing the video in the transcoder.
-func (c *NvencCodec) Scaler() string {
-	return ""
-}
-
-// ExtraArguments are the extra arguments used with this codec in the transcoder.
-func (c *NvencCodec) ExtraArguments() []string {
-	return nil
-}
-
-// ExtraFilters are the extra filters required for this codec in the transcoder.
-func (c *NvencCodec) ExtraFilters() string {
-	return ""
-}
-
-// VariantFlags returns a string representing a single variant processed by this codec.
-func (c *NvencCodec) VariantFlags(v *HLSVariant) []string {
-	tuning := "ll" // low latency
-	return []string{
-		fmt.Sprintf("-tune:v:%d", v.index), tuning,
-	}
-}
-
-// GetPresetForLevel returns the string preset for this codec given an integer level.
-func (c *NvencCodec) GetPresetForLevel(l int) string {
-	presetMapping := map[int]string{
-		0: "p1",
-		1: "p2",
-		2: "p3",
-		3: "p4",
-		4: "p5",
-	}
-
-	preset, ok := presetMapping[l]
-	if !ok {
-		defaultPreset := presetMapping[2]
-		log.Errorf("Invalid level for nvenc preset %d, defaulting to %s", l, defaultPreset)
-		return defaultPreset
-	}
-
-	return preset
-}
-
-// QuicksyncCodec represents an instance of the Intel Quicksync Codec.
-type QuicksyncCodec struct{}
-
-// Name returns the codec name.
-func (c *QuicksyncCodec) Name() string {
-	return "h264_qsv"
-}
-
-// DisplayName returns the human readable name of the codec.
-func (c *QuicksyncCodec) DisplayName() string {
-	return "Intel QuickSync"
-}
-
-// GlobalFlags are the global flags used with this codec in the transcoder.
-func (c *QuicksyncCodec) GlobalFlags() []string {
-	flags := []string{
-		"-init_hw_device", "qsv=hw",
-		"-filter_hw_device", "hw",
-	}
-
-	return flags
-}
-
-// PixelFormat is the pixel format required for this codec.
-func (c *QuicksyncCodec) PixelFormat() string {
-	return "qsv"
-}
-
-// Scaler is the scaler used for resizing the video in the transcoder.
-func (c *QuicksyncCodec) Scaler() string {
-	return "scale_qsv"
-}
-
-// ExtraArguments are the extra arguments used with this codec in the transcoder.
-func (c *QuicksyncCodec) ExtraArguments() []string {
-	return nil
-}
-
-// ExtraFilters are the extra filters required for this codec in the transcoder.
-func (c *QuicksyncCodec) ExtraFilters() string {
-	return "hwupload=extra_hw_frames=64,format=qsv"
-}
-
-// VariantFlags returns a string representing a single variant processed by this codec.
-func (c *QuicksyncCodec) VariantFlags(v *HLSVariant) []string {
-	return nil
-}
-
-// GetPresetForLevel returns the string preset for this codec given an integer level.
-func (c *QuicksyncCodec) GetPresetForLevel(l int) string {
-	presetMapping := map[int]string{
-		0: "veryfast",
-		1: "fast",
-		2: "medium",
-		3: "slow",
-		4: "veryslow",
-	}
-
-	preset, ok := presetMapping[l]
-	if !ok {
-		defaultPreset := presetMapping[2]
-		log.Errorf("Invalid level for quicksync preset %d, defaulting to %s", l, defaultPreset)
-		return defaultPreset
-	}
-
-	return preset
-}
-
-// Video4Linux represents an instance of the V4L Codec.
-type Video4Linux struct{}
-
-// Name returns the codec name.
-func (c *Video4Linux) Name() string {
-	return "h264_v4l2m2m"
-}
-
-// DisplayName returns the human readable name of the codec.
-func (c *Video4Linux) DisplayName() string {
-	return "Video4Linux"
-}
-
-// GlobalFlags are the global flags used with this codec in the transcoder.
-func (c *Video4Linux) GlobalFlags() []string {
-	return nil
-}
-
-// PixelFormat is the pixel format required for this codec.
-func (c *Video4Linux) PixelFormat() string {
-	return "nv21"
-}
-
-// Scaler is the scaler used for resizing the video in the transcoder.
-func (c *Video4Linux) Scaler() string {
-	return ""
-}
-
-// ExtraArguments are the extra arguments used with this codec in the transcoder.
-func (c *Video4Linux) ExtraArguments() []string {
-	return nil
-}
-
-// ExtraFilters are the extra filters required for this codec in the transcoder.
-func (c *Video4Linux) ExtraFilters() string {
-	return ""
-}
-
-// VariantFlags returns a string representing a single variant processed by this codec.
-func (c *Video4Linux) VariantFlags(v *HLSVariant) []string {
-	return nil
-}
-
-// GetPresetForLevel returns the string preset for this codec given an integer level.
-func (c *Video4Linux) GetPresetForLevel(l int) string {
-	presetMapping := map[int]string{
-		0: "ultrafast",
-		1: "superfast",
-		2: "veryfast",
-		3: "faster",
-		4: "fast",
-	}
-
-	preset, ok := presetMapping[l]
-	if !ok {
-		defaultPreset := presetMapping[1]
-		log.Errorf("Invalid level for v4l preset %d, defaulting to %s", l, defaultPreset)
-		return defaultPreset
-	}
-	return preset
-}
-
-// VideoToolboxCodec represents an instance of the VideoToolbox codec.
-type VideoToolboxCodec struct{}
-
-// Name returns the codec name.
-func (c *VideoToolboxCodec) Name() string {
-	return "h264_videotoolbox"
-}
-
-// DisplayName returns the human readable name of the codec.
-func (c *VideoToolboxCodec) DisplayName() string {
-	return "VideoToolbox"
-}
-
-// GlobalFlags are the global flags used with this codec in the transcoder.
-func (c *VideoToolboxCodec) GlobalFlags() []string {
-	return nil
-}
-
-// PixelFormat is the pixel format required for this codec.
-func (c *VideoToolboxCodec) PixelFormat() string {
-	return "nv12"
-}
-
-// Scaler is the scaler used for resizing the video in the transcoder.
-func (c *VideoToolboxCodec) Scaler() string {
-	return ""
-}
-
-// ExtraFilters are the extra filters required for this codec in the transcoder.
-func (c *VideoToolboxCodec) ExtraFilters() string {
-	return ""
-}
-
-// ExtraArguments are the extra arguments used with this codec in the transcoder.
-func (c *VideoToolboxCodec) ExtraArguments() []string {
-	return nil
-}
-
-// VariantFlags returns a string representing a single variant processed by this codec.
-func (c *VideoToolboxCodec) VariantFlags(v *HLSVariant) []string {
-	if v.cpuUsageLevel >= 3 {
-		return nil
-	}
-
-	return []string{"-realtime", "true"}
-}
-
-// GetPresetForLevel returns the string preset for this codec given an integer level.
-func (c *VideoToolboxCodec) GetPresetForLevel(l int) string {
-	presetMapping := map[int]string{
-		0: "ultrafast",
-		1: "superfast",
-		2: "veryfast",
-		3: "faster",
-		4: "fast",
-	}
-
-	preset, ok := presetMapping[l]
-	if !ok {
-		defaultPreset := presetMapping[1]
-		log.Errorf("Invalid level for videotoolbox preset %d, defaulting to %s", l, defaultPreset)
-		return defaultPreset
-	}
-
-	return preset
-}
-
-// GetCodecs will return the supported codecs available on the system.
-func GetCodecs(ffmpegPath string) []string {
-	codecs := make([]string, 0)
-
-	cmd := exec.Command(ffmpegPath, "-encoders")
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		log.Errorln(err)
-		return codecs
-	}
-
-	response := string(out)
-	lines := strings.Split(response, "\n")
-	for _, line := range lines {
-		if strings.Contains(line, "H.264") {
-			fields := strings.Fields(line)
-			codec := fields[1]
-			if _, supported := supportedCodecs[codec]; supported {
-				codecs = append(codecs, codec)
-			}
-		}
-	}
-
-	return codecs
-}
-
-func getCodec(name string) Codec {
-	switch name {
-	case (&NvencCodec{}).Name():
-		return &NvencCodec{}
-	case (&VaapiCodec{}).Name():
-		return &VaapiCodec{}
-	case (&QuicksyncCodec{}).Name():
-		return &QuicksyncCodec{}
-	case (&OmxCodec{}).Name():
-		return &OmxCodec{}
-	case (&Video4Linux{}).Name():
-		return &Video4Linux{}
-	case (&VideoToolboxCodec{}).Name():
-		return &VideoToolboxCodec{}
-	default:
-		return &Libx264Codec{}
-	}
-}

core/transcoder/codecsupport.go

@@ -0,0 +1,118 @@
+package transcoder
+
+import (
+	"os/exec"
+	"sort"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// EncoderCodecSupport describes which codecs an encoder supports on this system.
+type EncoderCodecSupport struct {
+	EncoderType          string   `json:"encoderType"`
+	EncoderDisplayName   string   `json:"encoderDisplayName"`
+	SupportedVideoCodecs []string `json:"supportedVideoCodecs"`
+}
+
+// GetAvailableVideoEncoders probes ffmpeg to discover which encoder+codec combinations
+// are available on this system. Returns only encoders that have at least one
+// supported codec available.
+func GetAvailableVideoEncoders(ffmpegPath string) []EncoderCodecSupport {
+	ffmpegEncoders := getFFmpegEncoders(ffmpegPath)
+
+	// Sort encoder names for deterministic output order.
+	encoderNames := make([]string, 0, len(encoderRegistry))
+	for name := range encoderRegistry {
+		encoderNames = append(encoderNames, name)
+	}
+	sort.Strings(encoderNames)
+
+	var available []EncoderCodecSupport
+	for _, name := range encoderNames {
+		enc := encoderRegistry[name]
+		var supportedCodecs []string
+		for _, codecName := range enc.SupportedVideoCodecs() {
+			ffmpegEncoderName := enc.FFmpegEncoderForCodec(codecName)
+			if _, ok := ffmpegEncoders[ffmpegEncoderName]; ok {
+				supportedCodecs = append(supportedCodecs, codecName)
+			}
+		}
+		if len(supportedCodecs) > 0 {
+			available = append(available, EncoderCodecSupport{
+				EncoderType:          enc.Name(),
+				EncoderDisplayName:   enc.DisplayName(),
+				SupportedVideoCodecs: supportedCodecs,
+			})
+		}
+	}
+
+	// Always include software encoder even if ffmpeg probe fails,
+	// as libx264 is almost universally available.
+	hasSoftware := false
+	for _, enc := range available {
+		if enc.EncoderType == "software" {
+			hasSoftware = true
+			break
+		}
+	}
+	if !hasSoftware {
+		available = append([]EncoderCodecSupport{{
+			EncoderType:          "software",
+			EncoderDisplayName:   "Software (CPU)",
+			SupportedVideoCodecs: []string{"h264"},
+		}}, available...)
+	}
+
+	return available
+}
+
+// GetAvailableAudioCodecs probes ffmpeg to discover which audio codecs are available.
+func GetAvailableAudioCodecs(ffmpegPath string) []string {
+	ffmpegEncoders := getFFmpegEncoders(ffmpegPath)
+	var available []string
+	for _, codec := range audioCodecRegistry {
+		if _, ok := ffmpegEncoders[codec.FFmpegEncoderName()]; ok {
+			available = append(available, codec.Name())
+		}
+	}
+	// Always include AAC as it is built into ffmpeg.
+	hasAAC := false
+	for _, name := range available {
+		if name == "aac" {
+			hasAAC = true
+			break
+		}
+	}
+	if !hasAAC {
+		available = append([]string{"aac"}, available...)
+	}
+	sort.Strings(available)
+	return available
+}
+
+// getFFmpegEncoders runs `ffmpeg -encoders` and returns a set of encoder names.
+func getFFmpegEncoders(ffmpegPath string) map[string]struct{} {
+	result := make(map[string]struct{})
+
+	cmd := exec.Command(ffmpegPath, "-encoders")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		log.Errorln(err)
+		return result
+	}
+
+	lines := strings.Split(string(out), "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if len(line) == 0 || line[0] == '-' || line[0] == '=' {
+			continue
+		}
+		fields := strings.Fields(line)
+		if len(fields) >= 2 {
+			result[fields[1]] = struct{}{}
+		}
+	}
+
+	return result
+}

core/transcoder/encoder.go

@@ -0,0 +1,128 @@
+package transcoder
+
+import (
+	"fmt"
+
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	pixelFormatYUV420P = "yuv420p"
+	ffmpegEncoderX264  = "libx264"
+)
+
+// CodecProfile holds codec-dependent encoding parameters for an encoder.
+type CodecProfile struct {
+	PixelFormat  string
+	Scaler       string
+	ExtraFilters string
+}
+
+// Encoder represents a hardware/software video encoding backend (e.g., software CPU, NVENC, VA-API).
+type Encoder interface {
+	Name() string
+	DisplayName() string
+	GlobalFlags() []string
+	ExtraArguments() []string
+	ProfileForCodec(codec string) CodecProfile
+	VariantFlags(v *HLSVariant) []string
+	SupportedVideoCodecs() []string
+	FFmpegEncoderForCodec(codec string) string
+	GetPresetForLevel(l int) string
+}
+
+// SoftwareEncoder uses CPU-based encoding via libx264/libx265.
+type SoftwareEncoder struct{}
+
+func (e *SoftwareEncoder) Name() string {
+	return "software"
+}
+
+func (e *SoftwareEncoder) DisplayName() string {
+	return "Software (CPU)"
+}
+
+func (e *SoftwareEncoder) GlobalFlags() []string {
+	return nil
+}
+
+func (e *SoftwareEncoder) ExtraArguments() []string {
+	return []string{"-tune", "zerolatency"}
+}
+
+func (e *SoftwareEncoder) ProfileForCodec(codec string) CodecProfile {
+	return CodecProfile{
+		PixelFormat: pixelFormatYUV420P,
+	}
+}
+
+func (e *SoftwareEncoder) VariantFlags(v *HLSVariant) []string {
+	codec := v.videoCodec.Name()
+	var flags []string
+
+	if codec == videoCodecH264 {
+		flags = append(flags,
+			fmt.Sprintf("-x264-params:v:%d", v.index), "scenecut=0:open_gop=0",
+		)
+	}
+
+	flags = append(flags,
+		fmt.Sprintf("-bufsize:v:%d", v.index), fmt.Sprintf("%dk", v.getBufferSize()),
+	)
+
+	if codec == videoCodecH264 {
+		flags = append(flags,
+			fmt.Sprintf("-profile:v:%d", v.index), "high",
+		)
+	}
+
+	return flags
+}
+
+func (e *SoftwareEncoder) SupportedVideoCodecs() []string {
+	return []string{videoCodecH264}
+}
+
+func (e *SoftwareEncoder) FFmpegEncoderForCodec(codec string) string {
+	switch codec {
+	case videoCodecH264:
+		return ffmpegEncoderX264
+	default:
+		log.Warnf("software encoder does not support codec %q, falling back to x264", codec)
+		return ffmpegEncoderX264
+	}
+}
+
+func (e *SoftwareEncoder) GetPresetForLevel(l int) string {
+	presetMapping := map[int]string{
+		0: "ultrafast",
+		1: "superfast",
+		2: "veryfast",
+		3: "faster",
+		4: "fast",
+	}
+	preset, ok := presetMapping[l]
+	if !ok {
+		defaultPreset := presetMapping[1]
+		log.Errorf("Invalid level for software preset %d, defaulting to %s", l, defaultPreset)
+		return defaultPreset
+	}
+	return preset
+}
+
+var encoderRegistry = map[string]Encoder{
+	"software":     &SoftwareEncoder{},
+	"nvenc":        &NvencEncoder{},
+	"vaapi":        &VaapiEncoder{},
+	"qsv":          &QuicksyncEncoder{},
+	"omx":          &OmxEncoder{},
+	"v4l2m2m":      &V4l2m2mEncoder{},
+	"videotoolbox": &VideoToolboxEncoder{},
+}
+
+func getEncoder(encoderType string) Encoder {
+	if enc, ok := encoderRegistry[encoderType]; ok {
+		return enc
+	}
+	return &SoftwareEncoder{}
+}

core/transcoder/encoder_nvenc.go

@@ -0,0 +1,71 @@
+package transcoder
+
+import (
+	"fmt"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// NvencEncoder uses NVIDIA GPU hardware encoding.
+type NvencEncoder struct{}
+
+func (e *NvencEncoder) Name() string {
+	return "nvenc"
+}
+
+func (e *NvencEncoder) DisplayName() string {
+	return "NVIDIA NVENC"
+}
+
+func (e *NvencEncoder) GlobalFlags() []string {
+	return []string{
+		"-hwaccel", "cuda",
+	}
+}
+
+func (e *NvencEncoder) ExtraArguments() []string {
+	return nil
+}
+
+func (e *NvencEncoder) ProfileForCodec(codec string) CodecProfile {
+	return CodecProfile{
+		PixelFormat: pixelFormatYUV420P,
+	}
+}
+
+func (e *NvencEncoder) VariantFlags(v *HLSVariant) []string {
+	return []string{
+		fmt.Sprintf("-tune:v:%d", v.index), "ll",
+	}
+}
+
+func (e *NvencEncoder) SupportedVideoCodecs() []string {
+	return []string{videoCodecH264}
+}
+
+func (e *NvencEncoder) FFmpegEncoderForCodec(codec string) string {
+	switch codec {
+	case videoCodecH264:
+		return "h264_nvenc"
+	default:
+		log.Warnf("nvenc encoder does not support codec %q, falling back to h264_nvenc", codec)
+		return "h264_nvenc"
+	}
+}
+
+func (e *NvencEncoder) GetPresetForLevel(l int) string {
+	presetMapping := map[int]string{
+		0: "p1",
+		1: "p2",
+		2: "p3",
+		3: "p4",
+		4: "p5",
+	}
+	preset, ok := presetMapping[l]
+	if !ok {
+		defaultPreset := presetMapping[2]
+		log.Errorf("Invalid level for nvenc preset %d, defaulting to %s", l, defaultPreset)
+		return defaultPreset
+	}
+	return preset
+}

core/transcoder/encoder_omx.go

@@ -0,0 +1,63 @@
+package transcoder
+
+import log "github.com/sirupsen/logrus"
+
+// OmxEncoder uses OpenMAX hardware encoding (Raspberry Pi / ARM).
+type OmxEncoder struct{}
+
+func (e *OmxEncoder) Name() string {
+	return "omx"
+}
+
+func (e *OmxEncoder) DisplayName() string {
+	return "OpenMAX (omx)"
+}
+
+func (e *OmxEncoder) GlobalFlags() []string {
+	return nil
+}
+
+func (e *OmxEncoder) ExtraArguments() []string {
+	return []string{"-tune", "zerolatency"}
+}
+
+func (e *OmxEncoder) ProfileForCodec(codec string) CodecProfile {
+	return CodecProfile{
+		PixelFormat: pixelFormatYUV420P,
+	}
+}
+
+func (e *OmxEncoder) VariantFlags(v *HLSVariant) []string {
+	return nil
+}
+
+func (e *OmxEncoder) SupportedVideoCodecs() []string {
+	return []string{videoCodecH264}
+}
+
+func (e *OmxEncoder) FFmpegEncoderForCodec(codec string) string {
+	switch codec {
+	case videoCodecH264:
+		return "h264_omx"
+	default:
+		log.Warnf("omx encoder does not support codec %q, falling back to h264_omx", codec)
+		return "h264_omx"
+	}
+}
+
+func (e *OmxEncoder) GetPresetForLevel(l int) string {
+	presetMapping := map[int]string{
+		0: "ultrafast",
+		1: "superfast",
+		2: "veryfast",
+		3: "faster",
+		4: "fast",
+	}
+	preset, ok := presetMapping[l]
+	if !ok {
+		defaultPreset := presetMapping[1]
+		log.Errorf("Invalid level for omx preset %d, defaulting to %s", l, defaultPreset)
+		return defaultPreset
+	}
+	return preset
+}

core/transcoder/encoder_qsv.go

@@ -0,0 +1,68 @@
+package transcoder
+
+import log "github.com/sirupsen/logrus"
+
+// QuicksyncEncoder uses Intel Quick Sync Video hardware encoding.
+type QuicksyncEncoder struct{}
+
+func (e *QuicksyncEncoder) Name() string {
+	return "qsv"
+}
+
+func (e *QuicksyncEncoder) DisplayName() string {
+	return "Intel QuickSync"
+}
+
+func (e *QuicksyncEncoder) GlobalFlags() []string {
+	return []string{
+		"-init_hw_device", "qsv=hw",
+		"-filter_hw_device", "hw",
+	}
+}
+
+func (e *QuicksyncEncoder) ExtraArguments() []string {
+	return nil
+}
+
+func (e *QuicksyncEncoder) ProfileForCodec(codec string) CodecProfile {
+	return CodecProfile{
+		PixelFormat:  "qsv",
+		Scaler:       "scale_qsv",
+		ExtraFilters: "hwupload=extra_hw_frames=64,format=qsv",
+	}
+}
+
+func (e *QuicksyncEncoder) VariantFlags(v *HLSVariant) []string {
+	return nil
+}
+
+func (e *QuicksyncEncoder) SupportedVideoCodecs() []string {
+	return []string{videoCodecH264}
+}
+
+func (e *QuicksyncEncoder) FFmpegEncoderForCodec(codec string) string {
+	switch codec {
+	case videoCodecH264:
+		return "h264_qsv"
+	default:
+		log.Warnf("quicksync encoder does not support codec %q, falling back to h264_qsv", codec)
+		return "h264_qsv"
+	}
+}
+
+func (e *QuicksyncEncoder) GetPresetForLevel(l int) string {
+	presetMapping := map[int]string{
+		0: "veryfast",
+		1: "fast",
+		2: "medium",
+		3: "slow",
+		4: "veryslow",
+	}
+	preset, ok := presetMapping[l]
+	if !ok {
+		defaultPreset := presetMapping[2]
+		log.Errorf("Invalid level for quicksync preset %d, defaulting to %s", l, defaultPreset)
+		return defaultPreset
+	}
+	return preset
+}

core/transcoder/encoder_v4l2m2m.go

@@ -0,0 +1,63 @@
+package transcoder
+
+import log "github.com/sirupsen/logrus"
+
+// V4l2m2mEncoder uses Video4Linux memory-to-memory hardware encoding.
+type V4l2m2mEncoder struct{}
+
+func (e *V4l2m2mEncoder) Name() string {
+	return "v4l2m2m"
+}
+
+func (e *V4l2m2mEncoder) DisplayName() string {
+	return "Video4Linux"
+}
+
+func (e *V4l2m2mEncoder) GlobalFlags() []string {
+	return nil
+}
+
+func (e *V4l2m2mEncoder) ExtraArguments() []string {
+	return nil
+}
+
+func (e *V4l2m2mEncoder) ProfileForCodec(codec string) CodecProfile {
+	return CodecProfile{
+		PixelFormat: "nv21",
+	}
+}
+
+func (e *V4l2m2mEncoder) VariantFlags(v *HLSVariant) []string {
+	return nil
+}
+
+func (e *V4l2m2mEncoder) SupportedVideoCodecs() []string {
+	return []string{videoCodecH264}
+}
+
+func (e *V4l2m2mEncoder) FFmpegEncoderForCodec(codec string) string {
+	switch codec {
+	case videoCodecH264:
+		return "h264_v4l2m2m"
+	default:
+		log.Warnf("v4l2m2m encoder does not support codec %q, falling back to h264_v4l2m2m", codec)
+		return "h264_v4l2m2m"
+	}
+}
+
+func (e *V4l2m2mEncoder) GetPresetForLevel(l int) string {
+	presetMapping := map[int]string{
+		0: "ultrafast",
+		1: "superfast",
+		2: "veryfast",
+		3: "faster",
+		4: "fast",
+	}
+	preset, ok := presetMapping[l]
+	if !ok {
+		defaultPreset := presetMapping[1]
+		log.Errorf("Invalid level for v4l preset %d, defaulting to %s", l, defaultPreset)
+		return defaultPreset
+	}
+	return preset
+}

core/transcoder/encoder_vaapi.go

@@ -0,0 +1,69 @@
+package transcoder
+
+import log "github.com/sirupsen/logrus"
+
+// VaapiEncoder uses VA-API hardware encoding (Intel/AMD GPUs).
+type VaapiEncoder struct{}
+
+func (e *VaapiEncoder) Name() string {
+	return "vaapi"
+}
+
+func (e *VaapiEncoder) DisplayName() string {
+	return "VA-API"
+}
+
+func (e *VaapiEncoder) GlobalFlags() []string {
+	return []string{
+		"-hwaccel", "vaapi",
+		"-hwaccel_output_format", "vaapi",
+		"-vaapi_device", "/dev/dri/renderD128",
+	}
+}
+
+func (e *VaapiEncoder) ExtraArguments() []string {
+	return nil
+}
+
+func (e *VaapiEncoder) ProfileForCodec(codec string) CodecProfile {
+	return CodecProfile{
+		PixelFormat:  "vaapi",
+		Scaler:       "scale_vaapi",
+		ExtraFilters: "hwupload=extra_hw_frames=64,format=vaapi",
+	}
+}
+
+func (e *VaapiEncoder) VariantFlags(v *HLSVariant) []string {
+	return nil
+}
+
+func (e *VaapiEncoder) SupportedVideoCodecs() []string {
+	return []string{videoCodecH264}
+}
+
+func (e *VaapiEncoder) FFmpegEncoderForCodec(codec string) string {
+	switch codec {
+	case videoCodecH264:
+		return "h264_vaapi"
+	default:
+		log.Warnf("vaapi encoder does not support codec %q, falling back to h264_vaapi", codec)
+		return "h264_vaapi"
+	}
+}
+
+func (e *VaapiEncoder) GetPresetForLevel(l int) string {
+	presetMapping := map[int]string{
+		0: "ultrafast",
+		1: "superfast",
+		2: "veryfast",
+		3: "faster",
+		4: "fast",
+	}
+	preset, ok := presetMapping[l]
+	if !ok {
+		defaultPreset := presetMapping[1]
+		log.Errorf("Invalid level for vaapi preset %d, defaulting to %s", l, defaultPreset)
+		return defaultPreset
+	}
+	return preset
+}

core/transcoder/encoder_videotoolbox.go

@@ -0,0 +1,66 @@
+package transcoder
+
+import log "github.com/sirupsen/logrus"
+
+// VideoToolboxEncoder uses Apple VideoToolbox hardware encoding (macOS).
+type VideoToolboxEncoder struct{}
+
+func (e *VideoToolboxEncoder) Name() string {
+	return "videotoolbox"
+}
+
+func (e *VideoToolboxEncoder) DisplayName() string {
+	return "VideoToolbox"
+}
+
+func (e *VideoToolboxEncoder) GlobalFlags() []string {
+	return nil
+}
+
+func (e *VideoToolboxEncoder) ExtraArguments() []string {
+	return nil
+}
+
+func (e *VideoToolboxEncoder) ProfileForCodec(codec string) CodecProfile {
+	return CodecProfile{
+		PixelFormat: "nv12",
+	}
+}
+
+func (e *VideoToolboxEncoder) VariantFlags(v *HLSVariant) []string {
+	if v.cpuUsageLevel >= 3 {
+		return nil
+	}
+	return []string{"-realtime", "true"}
+}
+
+func (e *VideoToolboxEncoder) SupportedVideoCodecs() []string {
+	return []string{videoCodecH264}
+}
+
+func (e *VideoToolboxEncoder) FFmpegEncoderForCodec(codec string) string {
+	switch codec {
+	case videoCodecH264:
+		return "h264_videotoolbox"
+	default:
+		log.Warnf("videotoolbox encoder does not support codec %q, falling back to h264_videotoolbox", codec)
+		return "h264_videotoolbox"
+	}
+}
+
+func (e *VideoToolboxEncoder) GetPresetForLevel(l int) string {
+	presetMapping := map[int]string{
+		0: "ultrafast",
+		1: "superfast",
+		2: "veryfast",
+		3: "faster",
+		4: "fast",
+	}
+	preset, ok := presetMapping[l]
+	if !ok {
+		defaultPreset := presetMapping[1]
+		log.Errorf("Invalid level for videotoolbox preset %d, defaulting to %s", l, defaultPreset)
+		return defaultPreset
+	}
+	return preset
+}

core/transcoder/fileWriterReceiverService.go

@@ -18,6 +18,7 @@ type FileWriterReceiverServiceCallback interface {
 	SegmentWritten(localFilePath string)
 	VariantPlaylistWritten(localFilePath string)
 	MasterPlaylistWritten(localFilePath string)
+	InitSegmentWritten(localFilePath string)
 }
 
 // FileWriterReceiverService accepts transcoder responses via HTTP and fires the callbacks.
@@ -81,8 +82,10 @@ func (s *FileWriterReceiverService) uploadHandler(w http.ResponseWriter, r *http
 func (s *FileWriterReceiverService) fileWritten(path string) {
 	if utils.GetRelativePathFromAbsolutePath(path) == "hls/stream.m3u8" {
 		s.callbacks.MasterPlaylistWritten(path)
-	} else if strings.HasSuffix(path, ".ts") {
+	} else if strings.HasSuffix(path, ".m4s") {
 		s.callbacks.SegmentWritten(path)
+	} else if strings.HasSuffix(path, "init.mp4") {
+		s.callbacks.InitSegmentWritten(path)
 	} else if strings.HasSuffix(path, ".m3u8") {
 		s.callbacks.VariantPlaylistWritten(path)
 	}

core/transcoder/hlsHandler.go

@@ -23,3 +23,8 @@ func (h *HLSHandler) VariantPlaylistWritten(localFilePath string) {
 func (h *HLSHandler) MasterPlaylistWritten(localFilePath string) {
 	h.Storage.MasterPlaylistWritten(localFilePath)
 }
+
+// InitSegmentWritten is fired when an fMP4 init segment is written to disk.
+func (h *HLSHandler) InitSegmentWritten(localFilePath string) {
+	h.Storage.SegmentWritten(localFilePath)
+}

core/transcoder/thumbnailGenerator.go

@@ -1,6 +1,7 @@
 package transcoder
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"path"
@@ -64,7 +65,7 @@ func fireThumbnailGenerator(segmentPath string, variantIndex int) error {
 	var modTime time.Time
 	var names []string
 	for _, f := range files {
-		if path.Ext(f.Name()) != ".ts" {
+		if path.Ext(f.Name()) != ".m4s" {
 			continue
 		}
 
@@ -88,7 +89,21 @@ func fireThumbnailGenerator(segmentPath string, variantIndex int) error {
 		return nil
 	}
 	configRepository := configrepository.Get()
+	// With multiple variants ffmpeg names init segments init_0.mp4, init_1.mp4, etc.
+	// With a single variant it uses init.mp4.
+	initSegment := path.Join(framePath, fmt.Sprintf("init_%d.mp4", variantIndex))
+	if !utils.DoesFileExists(initSegment) {
+		initSegment = path.Join(framePath, "init.mp4")
+	}
 	mostRecentFile := path.Join(framePath, names[0])
+
+	// The segment may have been cleaned up between ReadDir and now.
+	if !utils.DoesFileExists(mostRecentFile) {
+		return nil
+	}
+
+	// fMP4 segments require the init segment to be readable by ffmpeg
+	inputArg := fmt.Sprintf("concat:%s|%s", initSegment, mostRecentFile)
 	ffmpegPath := utils.ValidatedFfmpegPath(configRepository.GetFfMpegPath())
 	outputFileTemp := path.Join(config.TempDir, "tempthumbnail.jpg")
 
@@ -96,7 +111,7 @@ func fireThumbnailGenerator(segmentPath string, variantIndex int) error {
 		"-y",            // Overwrite file
 		"-threads", "1", // Low priority processing
 		"-t", "1", // Pull from frame 1
-		"-i", mostRecentFile, // Input
+		"-i", inputArg, // Input (init segment + media segment)
 		"-f", "image2", // format
 		"-vframes", "1", // Single frame
 		outputFileTemp,
@@ -111,7 +126,7 @@ func fireThumbnailGenerator(segmentPath string, variantIndex int) error {
 		log.Errorln(err)
 	}
 
-	makeAnimatedGifPreview(mostRecentFile, previewGifFile)
+	makeAnimatedGifPreview(inputArg, previewGifFile)
 
 	return nil
 }

core/transcoder/transcoder.go

@@ -33,7 +33,7 @@ func (e *execInfo) String() string {
 
 // Transcoder is a single instance of a video transcoder.
 type Transcoder struct {
-	codec Codec
+	encoder Encoder
 
 	stdin *io.PipeReader
 
@@ -66,6 +66,9 @@ type HLSVariant struct {
 	isVideoPassthrough bool // Override all settings and just copy the video stream
 
 	isAudioPassthrough bool // Override all settings and just copy the audio stream
+
+	videoCodec VideoCodec
+	audioCodec AudioCodec
 }
 
 // VideoSize is the scaled size of the video output.
@@ -127,7 +130,7 @@ func (t *Transcoder) Start(shouldLog bool) {
 
 	flags := t.getFlags()
 	if shouldLog {
-		log.Infof("Processing video using codec %s with %d output qualities configured.", t.codec.DisplayName(), len(t.variants))
+		log.Infof("Processing video using encoder %s with %d output qualities configured.", t.encoder.DisplayName(), len(t.variants))
 	}
 	createVariantDirectories()
 	command := flags.String()
@@ -167,7 +170,7 @@ func (t *Transcoder) Start(shouldLog bool) {
 	}
 
 	if err != nil {
-		log.Errorln("transcoding error. look at", logging.GetTranscoderLogFilePath(), "to help debug. your copy of ffmpeg may not support your selected codec of", t.codec.Name(), "https://owncast.online/docs/codecs/")
+		log.Errorln("transcoding error. look at", logging.GetTranscoderLogFilePath(), "to help debug. your copy of ffmpeg may not support your selected encoder of", t.encoder.Name(), "https://owncast.online/docs/codecs/")
 	}
 }
 
@@ -227,7 +230,7 @@ func (t *Transcoder) getFlags() *execInfo {
 	}
 	ffmpegFlags := make([]string, 0, 64)
 	ffmpegFlags = append(ffmpegFlags, "-hide_banner", "-loglevel", "warning")
-	ffmpegFlags = append(ffmpegFlags, t.codec.GlobalFlags()...)
+	ffmpegFlags = append(ffmpegFlags, t.encoder.GlobalFlags()...)
 	ffmpegFlags = append(ffmpegFlags, []string{
 		"-fflags", "+genpts", // Generate presentation time stamp if missing
 		"-flags", "+cgop", // Force closed GOPs
@@ -245,19 +248,20 @@ func (t *Transcoder) getFlags() *execInfo {
 	ffmpegFlags = append(ffmpegFlags, hlsOptionsString...)
 	ffmpegFlags = append(ffmpegFlags, hlsEventString...)
 	ffmpegFlags = append(ffmpegFlags, []string{
-		"-segment_format_options", "mpegts_flags=mpegts_copyts=1",
+		"-hls_segment_type", "fmp4",
+		"-hls_fmp4_init_filename", "init.mp4",
+		"-bsf:a", "aac_adtstoasc", // Convert AAC ADTS headers to ASC for fMP4 container compatibility
 	}...)
-	ffmpegFlags = append(ffmpegFlags, t.codec.ExtraArguments()...)
+	ffmpegFlags = append(ffmpegFlags, t.encoder.ExtraArguments()...)
 
 	ffmpegFlags = append(ffmpegFlags, []string{
 		// Video settings
-		"-pix_fmt", t.codec.PixelFormat(),
 		"-sc_threshold", "0", // Disable scene change detection for creating segments
 
 		// Filenames
 		"-master_pl_name", "stream.m3u8",
 
-		"-hls_segment_filename", localListenerAddress + "/%v/stream-" + t.segmentIdentifier + "-%d.ts", // Send HLS segments back to us over HTTP
+		"-hls_segment_filename", localListenerAddress + "/%v/stream-" + t.segmentIdentifier + "-%d.m4s", // Send HLS segments back to us over HTTP
 		"-max_muxing_queue_size", "400", // Workaround for Too many packets error: https://trac.ffmpeg.org/ticket/6375?cversion=0
 
 		"-method", "PUT", // HLS results sent back to us will be over PUTs
@@ -278,6 +282,9 @@ func getVariantFromConfigQuality(quality models.StreamOutputVariant, index int)
 	variant.isAudioPassthrough = quality.IsAudioPassthrough
 	variant.isVideoPassthrough = quality.IsVideoPassthrough
 
+	variant.videoCodec = getVideoCodec(quality.VideoCodec)
+	variant.audioCodec = getAudioCodec(quality.AudioCodec)
+
 	// If no audio bitrate is specified then we pass through original audio
 	if quality.AudioBitrate == 0 {
 		variant.isAudioPassthrough = true
@@ -318,7 +325,7 @@ func NewTranscoder() *Transcoder {
 
 	transcoder.currentStreamOutputSettings = configRepository.GetStreamOutputVariants()
 	transcoder.currentLatencyLevel = configRepository.GetStreamLatencyLevel()
-	transcoder.codec = getCodec(configRepository.GetVideoCodec())
+	transcoder.encoder = getEncoder(configRepository.GetVideoEncoder())
 	transcoder.segmentOutputPath = config.HLSStoragePath
 	transcoder.playlistOutputPath = config.HLSStoragePath
 
@@ -337,26 +344,28 @@ func (v *HLSVariant) getVariantString(t *Transcoder) []string {
 	variantEncoderCommands := v.getVideoQualityString(t)
 	variantEncoderCommands = append(variantEncoderCommands, v.getAudioQualityString()...)
 
+	profile := t.encoder.ProfileForCodec(v.videoCodec.Name())
+
 	if (v.videoSize.Width != 0 || v.videoSize.Height != 0) && !v.isVideoPassthrough {
 		// Order here matters, you must scale before changing hardware formats
 		filters := []string{
-			v.getScalingString(t.codec.Scaler()),
+			v.getScalingString(profile.Scaler),
 		}
-		if t.codec.ExtraFilters() != "" {
-			filters = append(filters, t.codec.ExtraFilters())
+		if profile.ExtraFilters != "" {
+			filters = append(filters, profile.ExtraFilters)
 		}
 		scalingAlgorithm := "bilinear"
 		variantEncoderCommands = append(variantEncoderCommands, []string{
 			"-sws_flags", scalingAlgorithm,
 			"-filter:v:" + strconv.Itoa(v.index), strings.Join(filters, ","),
 		}...)
-	} else if t.codec.ExtraFilters() != "" && !v.isVideoPassthrough {
+	} else if profile.ExtraFilters != "" && !v.isVideoPassthrough {
 		variantEncoderCommands = append(variantEncoderCommands, []string{
-			"-filter:v:" + strconv.Itoa(v.index), t.codec.ExtraFilters(),
+			"-filter:v:" + strconv.Itoa(v.index), profile.ExtraFilters,
 		}...)
 	}
 
-	preset := t.codec.GetPresetForLevel(v.cpuUsageLevel)
+	preset := t.encoder.GetPresetForLevel(v.cpuUsageLevel)
 	if preset != "" {
 		variantEncoderCommands = append(variantEncoderCommands, []string{
 			"-preset", preset,
@@ -415,18 +424,25 @@ func (v *HLSVariant) getVideoQualityString(t *Transcoder) []string {
 		}
 	}
 
+	codec := v.videoCodec.Name()
+	ffmpegEncoder := t.encoder.FFmpegEncoderForCodec(codec)
+	profile := t.encoder.ProfileForCodec(codec)
+
 	gop := v.framerate * t.currentLatencyLevel.SecondsPerSegment // force an i-frame every segment
 	cmd := make([]string, 0, 20)
 	cmd = append(cmd,
 		"-map", "v:0",
-		fmt.Sprintf("-c:v:%d", v.index), t.codec.Name(), // Video codec used for this variant
+		fmt.Sprintf("-c:v:%d", v.index), ffmpegEncoder, // Video encoder used for this variant
+		fmt.Sprintf("-pix_fmt:v:%d", v.index), profile.PixelFormat, // Pixel format for this variant
 		fmt.Sprintf("-b:v:%d", v.index), fmt.Sprintf("%dk", v.getAllocatedVideoBitrate()), // The average bitrate for this variant allowing space for audio
 		fmt.Sprintf("-maxrate:v:%d", v.index), fmt.Sprintf("%dk", v.getMaxVideoBitrate()), // The max bitrate allowed for this variant
 		fmt.Sprintf("-g:v:%d", v.index), fmt.Sprintf("%d", gop), // Suggested interval where i-frames are encoded into the segments
 		fmt.Sprintf("-keyint_min:v:%d", v.index), fmt.Sprintf("%d", gop), // minimum i-keyframe interval
 		fmt.Sprintf("-r:v:%d", v.index), fmt.Sprintf("%d", v.framerate),
 	)
-	cmd = append(cmd, t.codec.VariantFlags(v)...)
+
+	// Add encoder-specific variant flags (e.g., x264-params for software, NVENC low-latency tuning).
+	cmd = append(cmd, t.encoder.VariantFlags(v)...)
 
 	return cmd
 }
@@ -455,11 +471,9 @@ func (v *HLSVariant) getAudioQualityString() []string {
 		}
 	}
 
-	// libfdk_aac is not a part of every ffmpeg install, so use "aac" instead
-	encoderCodec := "aac"
 	return []string{
 		"-map", "a:0?",
-		fmt.Sprintf("-c:a:%d", v.index), encoderCodec,
+		fmt.Sprintf("-c:a:%d", v.index), v.audioCodec.FFmpegEncoderName(),
 		fmt.Sprintf("-b:a:%d", v.index), v.audioBitrate,
 	}
 }
@@ -495,7 +509,7 @@ func (t *Transcoder) SetInternalHTTPPort(port string) {
 	t.internalListenerPort = port
 }
 
-// SetCodec will set the codec to be used for the transocder.
-func (t *Transcoder) SetCodec(codecName string) {
-	t.codec = getCodec(codecName)
+// SetEncoder will set the encoder to be used for the transcoder.
+func (t *Transcoder) SetEncoder(encoderType string) {
+	t.encoder = getEncoder(encoderType)
 }

core/transcoder/transcoder_nvenc_test.go

@@ -9,7 +9,6 @@ import (
 
 func TestFFmpegNvencCommand(t *testing.T) {
 	latencyLevel := models.GetLatencyLevel(2)
-	codec := NvencCodec{}
 
 	transcoder := new(Transcoder)
 	transcoder.ffmpegPath = filepath.Join("fake", "path", "ffmpeg")
@@ -17,12 +16,14 @@ func TestFFmpegNvencCommand(t *testing.T) {
 	transcoder.SetOutputPath("fakeOutput")
 	transcoder.SetIdentifier("jdoieGg")
 	transcoder.SetInternalHTTPPort("8123")
-	transcoder.SetCodec(codec.Name())
+	transcoder.SetEncoder("nvenc")
 	transcoder.currentLatencyLevel = latencyLevel
 
 	variant := HLSVariant{}
 	variant.videoBitrate = 1200
 	variant.isAudioPassthrough = true
+	variant.videoCodec = &H264Codec{}
+	variant.audioCodec = &AACCodec{}
 	variant.SetVideoFramerate(30)
 	variant.SetCPUUsageLevel(2)
 	transcoder.AddVariant(variant)
@@ -30,6 +31,8 @@ func TestFFmpegNvencCommand(t *testing.T) {
 	variant2 := HLSVariant{}
 	variant2.videoBitrate = 3500
 	variant2.isAudioPassthrough = true
+	variant2.videoCodec = &H264Codec{}
+	variant2.audioCodec = &AACCodec{}
 	variant2.SetVideoFramerate(24)
 	variant2.SetCPUUsageLevel(4)
 	transcoder.AddVariant(variant2)
@@ -37,12 +40,14 @@ func TestFFmpegNvencCommand(t *testing.T) {
 	variant3 := HLSVariant{}
 	variant3.isAudioPassthrough = true
 	variant3.isVideoPassthrough = true
+	variant3.videoCodec = &H264Codec{}
+	variant3.audioCodec = &AACCodec{}
 	transcoder.AddVariant(variant3)
 
 	cmd := transcoder.GetString()
 
 	expectedLogPath := "data/logs/transcoder.log"
-	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -hwaccel cuda -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_nvenc -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -tune:v:0 ll -map a:0? -c:a:0 copy -preset p3 -map v:0 -c:v:1 h264_nvenc -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -tune:v:1 ll -map a:0? -c:a:1 copy -preset p5 -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset p1 -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -segment_format_options mpegts_flags=mpegts_copyts=1 -pix_fmt yuv420p -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdoieGg-%d.ts -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
+	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -hwaccel cuda -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_nvenc -pix_fmt:v:0 yuv420p -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -tune:v:0 ll -map a:0? -c:a:0 copy -preset p3 -map v:0 -c:v:1 h264_nvenc -pix_fmt:v:1 yuv420p -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -tune:v:1 ll -map a:0? -c:a:1 copy -preset p5 -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset p1 -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -hls_segment_type fmp4 -hls_fmp4_init_filename init.mp4 -bsf:a aac_adtstoasc -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdoieGg-%d.m4s -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
 
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)

core/transcoder/transcoder_omx_test.go

@@ -9,7 +9,6 @@ import (
 
 func TestFFmpegOmxCommand(t *testing.T) {
 	latencyLevel := models.GetLatencyLevel(2)
-	codec := OmxCodec{}
 
 	transcoder := new(Transcoder)
 	transcoder.ffmpegPath = filepath.Join("fake", "path", "ffmpeg")
@@ -17,12 +16,14 @@ func TestFFmpegOmxCommand(t *testing.T) {
 	transcoder.SetOutputPath("fakeOutput")
 	transcoder.SetIdentifier("jdFsdfzGg")
 	transcoder.SetInternalHTTPPort("8123")
-	transcoder.SetCodec(codec.Name())
+	transcoder.SetEncoder("omx")
 	transcoder.currentLatencyLevel = latencyLevel
 
 	variant := HLSVariant{}
 	variant.videoBitrate = 1200
 	variant.isAudioPassthrough = true
+	variant.videoCodec = &H264Codec{}
+	variant.audioCodec = &AACCodec{}
 	variant.SetVideoFramerate(30)
 	variant.SetCPUUsageLevel(2)
 	transcoder.AddVariant(variant)
@@ -30,6 +31,8 @@ func TestFFmpegOmxCommand(t *testing.T) {
 	variant2 := HLSVariant{}
 	variant2.videoBitrate = 3500
 	variant2.isAudioPassthrough = true
+	variant2.videoCodec = &H264Codec{}
+	variant2.audioCodec = &AACCodec{}
 	variant2.SetVideoFramerate(24)
 	variant2.SetCPUUsageLevel(4)
 	transcoder.AddVariant(variant2)
@@ -37,12 +40,14 @@ func TestFFmpegOmxCommand(t *testing.T) {
 	variant3 := HLSVariant{}
 	variant3.isAudioPassthrough = true
 	variant3.isVideoPassthrough = true
+	variant3.videoCodec = &H264Codec{}
+	variant3.audioCodec = &AACCodec{}
 	transcoder.AddVariant(variant3)
 
 	cmd := transcoder.GetString()
 
 	expectedLogPath := "data/logs/transcoder.log"
-	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_omx -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -map a:0? -c:a:0 copy -preset veryfast -map v:0 -c:v:1 h264_omx -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -map a:0? -c:a:1 copy -preset fast -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset ultrafast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -segment_format_options mpegts_flags=mpegts_copyts=1 -tune zerolatency -pix_fmt yuv420p -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdFsdfzGg-%d.ts -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
+	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_omx -pix_fmt:v:0 yuv420p -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -map a:0? -c:a:0 copy -preset veryfast -map v:0 -c:v:1 h264_omx -pix_fmt:v:1 yuv420p -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -map a:0? -c:a:1 copy -preset fast -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset ultrafast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -hls_segment_type fmp4 -hls_fmp4_init_filename init.mp4 -bsf:a aac_adtstoasc -tune zerolatency -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdFsdfzGg-%d.m4s -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
 
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)

core/transcoder/transcoder_qsv_test.go

@@ -9,7 +9,6 @@ import (
 
 func TestFFmpegQuicksyncCommand(t *testing.T) {
 	latencyLevel := models.GetLatencyLevel(2)
-	codec := QuicksyncCodec{}
 
 	transcoder := new(Transcoder)
 	transcoder.ffmpegPath = filepath.Join("fake", "path", "ffmpeg")
@@ -17,12 +16,14 @@ func TestFFmpegQuicksyncCommand(t *testing.T) {
 	transcoder.SetOutputPath("fakeOutput")
 	transcoder.SetIdentifier("jdofFGg")
 	transcoder.SetInternalHTTPPort("8123")
-	transcoder.SetCodec(codec.Name())
+	transcoder.SetEncoder("qsv")
 	transcoder.currentLatencyLevel = latencyLevel
 
 	variant := HLSVariant{}
 	variant.videoBitrate = 1200
 	variant.isAudioPassthrough = true
+	variant.videoCodec = &H264Codec{}
+	variant.audioCodec = &AACCodec{}
 	variant.SetVideoFramerate(30)
 	variant.SetCPUUsageLevel(2)
 	transcoder.AddVariant(variant)
@@ -30,6 +31,8 @@ func TestFFmpegQuicksyncCommand(t *testing.T) {
 	variant2 := HLSVariant{}
 	variant2.videoBitrate = 3500
 	variant2.isAudioPassthrough = true
+	variant2.videoCodec = &H264Codec{}
+	variant2.audioCodec = &AACCodec{}
 	variant2.SetVideoFramerate(24)
 	variant2.SetCPUUsageLevel(4)
 	transcoder.AddVariant(variant2)
@@ -37,12 +40,14 @@ func TestFFmpegQuicksyncCommand(t *testing.T) {
 	variant3 := HLSVariant{}
 	variant3.isAudioPassthrough = true
 	variant3.isVideoPassthrough = true
+	variant3.videoCodec = &H264Codec{}
+	variant3.audioCodec = &AACCodec{}
 	transcoder.AddVariant(variant3)
 
 	cmd := transcoder.GetString()
 
 	expectedLogPath := "data/logs/transcoder.log"
-	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -init_hw_device qsv=hw -filter_hw_device hw -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_qsv -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -map a:0? -c:a:0 copy -filter:v:0 hwupload=extra_hw_frames=64,format=qsv -preset medium -map v:0 -c:v:1 h264_qsv -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -map a:0? -c:a:1 copy -filter:v:1 hwupload=extra_hw_frames=64,format=qsv -preset veryslow -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset veryfast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -segment_format_options mpegts_flags=mpegts_copyts=1 -pix_fmt qsv -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdofFGg-%d.ts -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
+	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -init_hw_device qsv=hw -filter_hw_device hw -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_qsv -pix_fmt:v:0 qsv -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -map a:0? -c:a:0 copy -filter:v:0 hwupload=extra_hw_frames=64,format=qsv -preset medium -map v:0 -c:v:1 h264_qsv -pix_fmt:v:1 qsv -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -map a:0? -c:a:1 copy -filter:v:1 hwupload=extra_hw_frames=64,format=qsv -preset veryslow -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset veryfast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -hls_segment_type fmp4 -hls_fmp4_init_filename init.mp4 -bsf:a aac_adtstoasc -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdofFGg-%d.m4s -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
 
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)

core/transcoder/transcoder_vaapi_test.go

@@ -9,7 +9,6 @@ import (
 
 func TestFFmpegVaapiCommand(t *testing.T) {
 	latencyLevel := models.GetLatencyLevel(2)
-	codec := VaapiCodec{}
 
 	transcoder := new(Transcoder)
 	transcoder.ffmpegPath = filepath.Join("fake", "path", "ffmpeg")
@@ -17,12 +16,14 @@ func TestFFmpegVaapiCommand(t *testing.T) {
 	transcoder.SetOutputPath("fakeOutput")
 	transcoder.SetIdentifier("jdofFGg")
 	transcoder.SetInternalHTTPPort("8123")
-	transcoder.SetCodec(codec.Name())
+	transcoder.SetEncoder("vaapi")
 	transcoder.currentLatencyLevel = latencyLevel
 
 	variant := HLSVariant{}
 	variant.videoBitrate = 1200
 	variant.isAudioPassthrough = true
+	variant.videoCodec = &H264Codec{}
+	variant.audioCodec = &AACCodec{}
 	variant.SetVideoFramerate(30)
 	variant.SetCPUUsageLevel(2)
 	transcoder.AddVariant(variant)
@@ -30,6 +31,8 @@ func TestFFmpegVaapiCommand(t *testing.T) {
 	variant2 := HLSVariant{}
 	variant2.videoBitrate = 3500
 	variant2.isAudioPassthrough = true
+	variant2.videoCodec = &H264Codec{}
+	variant2.audioCodec = &AACCodec{}
 	variant2.SetVideoFramerate(24)
 	variant2.SetCPUUsageLevel(4)
 	transcoder.AddVariant(variant2)
@@ -37,12 +40,14 @@ func TestFFmpegVaapiCommand(t *testing.T) {
 	variant3 := HLSVariant{}
 	variant3.isAudioPassthrough = true
 	variant3.isVideoPassthrough = true
+	variant3.videoCodec = &H264Codec{}
+	variant3.audioCodec = &AACCodec{}
 	transcoder.AddVariant(variant3)
 
 	cmd := transcoder.GetString()
 
 	expectedLogPath := "data/logs/transcoder.log"
-	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -hwaccel vaapi -hwaccel_output_format vaapi -vaapi_device /dev/dri/renderD128 -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_vaapi -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -map a:0? -c:a:0 copy -filter:v:0 hwupload=extra_hw_frames=64,format=vaapi -preset veryfast -map v:0 -c:v:1 h264_vaapi -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -map a:0? -c:a:1 copy -filter:v:1 hwupload=extra_hw_frames=64,format=vaapi -preset fast -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset ultrafast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -segment_format_options mpegts_flags=mpegts_copyts=1 -pix_fmt vaapi -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdofFGg-%d.ts -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
+	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -hwaccel vaapi -hwaccel_output_format vaapi -vaapi_device /dev/dri/renderD128 -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_vaapi -pix_fmt:v:0 vaapi -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -map a:0? -c:a:0 copy -filter:v:0 hwupload=extra_hw_frames=64,format=vaapi -preset veryfast -map v:0 -c:v:1 h264_vaapi -pix_fmt:v:1 vaapi -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -map a:0? -c:a:1 copy -filter:v:1 hwupload=extra_hw_frames=64,format=vaapi -preset fast -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset ultrafast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -hls_segment_type fmp4 -hls_fmp4_init_filename init.mp4 -bsf:a aac_adtstoasc -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdofFGg-%d.m4s -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
 
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)

core/transcoder/transcoder_videotoolbox_test.go

@@ -9,7 +9,6 @@ import (
 
 func TestFFmpegVideoToolboxCommand(t *testing.T) {
 	latencyLevel := models.GetLatencyLevel(2)
-	codec := VideoToolboxCodec{}
 
 	transcoder := new(Transcoder)
 	transcoder.ffmpegPath = filepath.Join("fake", "path", "ffmpeg")
@@ -17,12 +16,14 @@ func TestFFmpegVideoToolboxCommand(t *testing.T) {
 	transcoder.SetOutputPath("fakeOutput")
 	transcoder.SetIdentifier("jdFsdfzGg")
 	transcoder.SetInternalHTTPPort("8123")
-	transcoder.SetCodec(codec.Name())
+	transcoder.SetEncoder("videotoolbox")
 	transcoder.currentLatencyLevel = latencyLevel
 
 	variant := HLSVariant{}
 	variant.videoBitrate = 1200
 	variant.isAudioPassthrough = true
+	variant.videoCodec = &H264Codec{}
+	variant.audioCodec = &AACCodec{}
 	variant.SetVideoFramerate(30)
 	variant.SetCPUUsageLevel(2)
 	transcoder.AddVariant(variant)
@@ -30,6 +31,8 @@ func TestFFmpegVideoToolboxCommand(t *testing.T) {
 	variant2 := HLSVariant{}
 	variant2.videoBitrate = 3500
 	variant2.isAudioPassthrough = true
+	variant2.videoCodec = &H264Codec{}
+	variant2.audioCodec = &AACCodec{}
 	variant2.SetVideoFramerate(24)
 	variant2.SetCPUUsageLevel(4)
 	transcoder.AddVariant(variant2)
@@ -37,12 +40,14 @@ func TestFFmpegVideoToolboxCommand(t *testing.T) {
 	variant3 := HLSVariant{}
 	variant3.isAudioPassthrough = true
 	variant3.isVideoPassthrough = true
+	variant3.videoCodec = &H264Codec{}
+	variant3.audioCodec = &AACCodec{}
 	transcoder.AddVariant(variant3)
 
 	cmd := transcoder.GetString()
 
 	expectedLogPath := "data/logs/transcoder.log"
-	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_videotoolbox -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -realtime true -map a:0? -c:a:0 copy -preset veryfast -map v:0 -c:v:1 h264_videotoolbox -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -map a:0? -c:a:1 copy -preset fast -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset ultrafast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -segment_format_options mpegts_flags=mpegts_copyts=1 -pix_fmt nv12 -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdFsdfzGg-%d.ts -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
+	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 h264_videotoolbox -pix_fmt:v:0 nv12 -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -realtime true -map a:0? -c:a:0 copy -preset veryfast -map v:0 -c:v:1 h264_videotoolbox -pix_fmt:v:1 nv12 -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -map a:0? -c:a:1 copy -preset fast -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset ultrafast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -hls_segment_type fmp4 -hls_fmp4_init_filename init.mp4 -bsf:a aac_adtstoasc -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdFsdfzGg-%d.m4s -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
 
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)

core/transcoder/transcoder_x264_test.go

@@ -9,7 +9,6 @@ import (
 
 func TestFFmpegx264Command(t *testing.T) {
 	latencyLevel := models.GetLatencyLevel(2)
-	codec := Libx264Codec{}
 
 	transcoder := new(Transcoder)
 	transcoder.ffmpegPath = filepath.Join("fake", "path", "ffmpeg")
@@ -17,12 +16,14 @@ func TestFFmpegx264Command(t *testing.T) {
 	transcoder.SetOutputPath("fakeOutput")
 	transcoder.SetIdentifier("jdofFGg")
 	transcoder.SetInternalHTTPPort("8123")
-	transcoder.SetCodec(codec.Name())
+	transcoder.SetEncoder("software")
 	transcoder.currentLatencyLevel = latencyLevel
 
 	variant := HLSVariant{}
 	variant.videoBitrate = 1200
 	variant.isAudioPassthrough = true
+	variant.videoCodec = &H264Codec{}
+	variant.audioCodec = &AACCodec{}
 	variant.SetVideoFramerate(30)
 	variant.SetCPUUsageLevel(2)
 	transcoder.AddVariant(variant)
@@ -30,6 +31,8 @@ func TestFFmpegx264Command(t *testing.T) {
 	variant2 := HLSVariant{}
 	variant2.videoBitrate = 3500
 	variant2.isAudioPassthrough = true
+	variant2.videoCodec = &H264Codec{}
+	variant2.audioCodec = &AACCodec{}
 	variant2.SetVideoFramerate(24)
 	variant2.SetCPUUsageLevel(4)
 	transcoder.AddVariant(variant2)
@@ -37,12 +40,14 @@ func TestFFmpegx264Command(t *testing.T) {
 	variant3 := HLSVariant{}
 	variant3.isAudioPassthrough = true
 	variant3.isVideoPassthrough = true
+	variant3.videoCodec = &H264Codec{}
+	variant3.audioCodec = &AACCodec{}
 	transcoder.AddVariant(variant3)
 
 	cmd := transcoder.GetString()
 
 	expectedLogPath := "data/logs/transcoder.log"
-	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 libx264 -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -x264-params:v:0 scenecut=0:open_gop=0 -bufsize:v:0 1088k -profile:v:0 high -map a:0? -c:a:0 copy -preset veryfast -map v:0 -c:v:1 libx264 -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -x264-params:v:1 scenecut=0:open_gop=0 -bufsize:v:1 3572k -profile:v:1 high -map a:0? -c:a:1 copy -preset fast -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset ultrafast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -segment_format_options mpegts_flags=mpegts_copyts=1 -tune zerolatency -pix_fmt yuv420p -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdofFGg-%d.ts -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
+	expected := `FFREPORT=file=` + expectedLogPath + `:level=32 ` + transcoder.ffmpegPath + ` -hide_banner -loglevel warning -fflags +genpts -flags +cgop -i fakecontent.flv -map v:0 -c:v:0 libx264 -pix_fmt:v:0 yuv420p -b:v:0 1008k -maxrate:v:0 1088k -g:v:0 90 -keyint_min:v:0 90 -r:v:0 30 -x264-params:v:0 scenecut=0:open_gop=0 -bufsize:v:0 1088k -profile:v:0 high -map a:0? -c:a:0 copy -preset veryfast -map v:0 -c:v:1 libx264 -pix_fmt:v:1 yuv420p -b:v:1 3308k -maxrate:v:1 3572k -g:v:1 72 -keyint_min:v:1 72 -r:v:1 24 -x264-params:v:1 scenecut=0:open_gop=0 -bufsize:v:1 3572k -profile:v:1 high -map a:0? -c:a:1 copy -preset fast -map v:0 -c:v:2 copy -map a:0? -c:a:2 copy -preset ultrafast -var_stream_map v:0,a:0 v:1,a:1 v:2,a:2 -f hls -hls_time 3 -hls_list_size 10 -hls_flags program_date_time+independent_segments+omit_endlist -hls_segment_type fmp4 -hls_fmp4_init_filename init.mp4 -bsf:a aac_adtstoasc -tune zerolatency -sc_threshold 0 -master_pl_name stream.m3u8 -hls_segment_filename http://127.0.0.1:8123/%v/stream-jdofFGg-%d.m4s -max_muxing_queue_size 400 -method PUT http://127.0.0.1:8123/%v/stream.m3u8`
 
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)

core/transcoder/videocodec.go

@@ -0,0 +1,31 @@
+package transcoder
+
+const videoCodecH264 = "h264"
+
+// VideoCodec represents a video compression format (e.g., H.264, H.265).
+type VideoCodec interface {
+	Name() string
+	DisplayName() string
+}
+
+// H264Codec implements VideoCodec for the H.264 format.
+type H264Codec struct{}
+
+func (c *H264Codec) Name() string {
+	return videoCodecH264
+}
+
+func (c *H264Codec) DisplayName() string {
+	return "H.264"
+}
+
+var videoCodecRegistry = map[string]VideoCodec{
+	videoCodecH264: &H264Codec{},
+}
+
+func getVideoCodec(name string) VideoCodec {
+	if codec, ok := videoCodecRegistry[name]; ok {
+		return codec
+	}
+	return &H264Codec{}
+}

go.mod

@@ -27,7 +27,7 @@ require (
 	github.com/prometheus/client_golang v1.23.2
 	github.com/rifflock/lfshook v0.0.0-20180920164130-b9218ef580f5
 	github.com/schollz/sqlite3dump v1.3.1
-	github.com/shirou/gopsutil/v4 v4.25.8
+	github.com/shirou/gopsutil/v4 v4.26.2
 	github.com/sirupsen/logrus v1.9.4
 	github.com/stretchr/testify v1.11.1
 	github.com/teris-io/shortid v0.0.0-20220617161101-71ec9f2aa569
@@ -48,7 +48,8 @@ require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/ebitengine/purego v0.8.4 // indirect
+	github.com/ebitengine/purego v0.10.0 // indirect
+	github.com/fatih/color v1.19.0 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/golang-jwt/jwt/v5 v5.2.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
@@ -66,14 +67,16 @@ require (
 	github.com/prometheus/client_model v0.6.2 // indirect
 	github.com/prometheus/common v0.66.1 // indirect
 	github.com/prometheus/procfs v0.16.1 // indirect
-	github.com/tklauser/go-sysconf v0.3.15 // indirect
-	github.com/tklauser/numcpus v0.10.0 // indirect
+	github.com/rogpeppe/go-internal v1.14.1 // indirect
+	github.com/tklauser/go-sysconf v0.3.16 // indirect
+	github.com/tklauser/numcpus v0.11.0 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
 	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.43.0 // indirect
 	golang.org/x/text v0.36.0 // indirect
 	google.golang.org/protobuf v1.36.8 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 

go.sum

@@ -24,10 +24,10 @@ github.com/dave/jennifer v1.3.0/go.mod h1:fIb+770HOpJ2fmN9EPPKOqm1vMGhB+TwXKMZhr
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
-github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
-github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
-github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
+github.com/ebitengine/purego v0.10.0 h1:QIw4xfpWT6GWTzaW5XEKy3HXoqrJGx1ijYHzTF0/ISU=
+github.com/ebitengine/purego v0.10.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/fatih/color v1.19.0 h1:Zp3PiM21/9Ld6FzSKyL5c/BULoe/ONr9KlbYVOfG8+w=
+github.com/fatih/color v1.19.0/go.mod h1:zNk67I0ZUT1bEGsSGyCZYZNrHuTkJJB+r6Q9VuMi0LE=
 github.com/go-chi/chi/v5 v5.2.3 h1:WQIt9uxdsAbgIYgid+BpYc+liqQZGMHRaUwp0JUcvdE=
 github.com/go-chi/chi/v5 v5.2.3/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
 github.com/go-fed/httpsig v0.1.1-0.20190914113940-c2de3672e5b5/go.mod h1:T56HUNYZUQ1AGUzhAYPugZfp36sKApVnGBgKlIY+aIE=
@@ -87,21 +87,11 @@ github.com/lestrrat-go/strftime v1.1.1 h1:zgf8QCsgj27GlKBy3SU9/8MMgegZ8UCzlCyHYr
 github.com/lestrrat-go/strftime v1.1.1/go.mod h1:YDrzHJAODYQ+xxvrn5SG01uFIQAeDTzpxNVppCz7Nmw=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.7/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
-github.com/mattn/go-sqlite3 v1.14.37 h1:3DOZp4cXis1cUIpCfXLtmlGolNLp2VEqhiB/PARNBIg=
-github.com/mattn/go-sqlite3 v1.14.37/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/mattn/go-sqlite3 v1.14.38 h1:tDUzL85kMvOrvpCt8P64SbGgVFtJB11GPi2AdmITgb4=
-github.com/mattn/go-sqlite3 v1.14.38/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/mattn/go-sqlite3 v1.14.39 h1:sIwSjlJGOaRJjw44/HXaeTblZMjseqr6OOio1tz/+JI=
-github.com/mattn/go-sqlite3 v1.14.39/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/mattn/go-sqlite3 v1.14.40 h1:f7+saIsbq4EF86mUqe0uiecQOJYMOdfi5uATADmUG94=
-github.com/mattn/go-sqlite3 v1.14.40/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
-github.com/mattn/go-sqlite3 v1.14.41 h1:8p7Pwz5NHkEbWSqc/ygU4CBGubhFFkpgP9KwcdkAHNA=
-github.com/mattn/go-sqlite3 v1.14.41/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
 github.com/mattn/go-sqlite3 v1.14.42 h1:MigqEP4ZmHw3aIdIT7T+9TLa90Z6smwcthx+Azv4Cgo=
 github.com/mattn/go-sqlite3 v1.14.42/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ=
 github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
@@ -114,10 +104,6 @@ github.com/nakabonne/tstorage v0.3.6 h1:usp7pTohax8mynnFiUSUQ2QVBCKLCkYx3gmb3+rJ
 github.com/nakabonne/tstorage v0.3.6/go.mod h1:1xUrK3s1MXSlU6dn96xHerHx/MdO4BGmsAHEUbsaOxU=
 github.com/nareix/joy5 v0.0.0-20210317075623-2c912ca30590 h1:PnxRU8L8Y2q82vFC2QdNw23Dm2u6WrjecIdpXjiYbXM=
 github.com/nareix/joy5 v0.0.0-20210317075623-2c912ca30590/go.mod h1:XmAOs6UJXpNXRwKk+KY/nv5kL6xXYXyellk+A1pTlko=
-github.com/oapi-codegen/runtime v1.3.0 h1:vyK1zc0gDWWXgk2xoQa4+X4RNNc5SL2RbTpJS/4vMYA=
-github.com/oapi-codegen/runtime v1.3.0/go.mod h1:kOdeacKy7t40Rclb1je37ZLFboFxh+YLy0zaPCMibPY=
-github.com/oapi-codegen/runtime v1.3.1 h1:RgDY6J4OGQLbRXhG/Xpt3vSVqYpHQS7hN4m85+5xB9g=
-github.com/oapi-codegen/runtime v1.3.1/go.mod h1:kOdeacKy7t40Rclb1je37ZLFboFxh+YLy0zaPCMibPY=
 github.com/oapi-codegen/runtime v1.4.0 h1:KLOSFOp7UzkbS7Cs1ms6NBEKYr0WmH2wZG0KKbd2er4=
 github.com/oapi-codegen/runtime v1.4.0/go.mod h1:5sw5fxCDmnOzKNYmkVNF8d34kyUeejJEY8HNT2WaPec=
 github.com/oschwald/geoip2-golang v1.13.0 h1:Q44/Ldc703pasJeP5V9+aFSZFmBN7DKHbNsSFzQATJI=
@@ -144,12 +130,12 @@ github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzM
 github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
 github.com/rifflock/lfshook v0.0.0-20180920164130-b9218ef580f5 h1:mZHayPoR0lNmnHyvtYjDeq0zlVHn9K/ZXoy17ylucdo=
 github.com/rifflock/lfshook v0.0.0-20180920164130-b9218ef580f5/go.mod h1:GEXHk5HgEKCvEIIrSpFI3ozzG5xOKA2DVlEX/gGnewM=
-github.com/rogpeppe/go-internal v1.13.2-0.20241226121412-a5dc8ff20d0a h1:w3tdWGKbLGBPtR/8/oO74W6hmz0qE5q0z9aqSAewaaM=
-github.com/rogpeppe/go-internal v1.13.2-0.20241226121412-a5dc8ff20d0a/go.mod h1:S8kfXMp+yh77OxPD4fdM6YUknrZpQxLhvxzS4gDHENY=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/schollz/sqlite3dump v1.3.1 h1:QXizJ7XEJ7hggjqjZ3YRtF3+javm8zKtzNByYtEkPRA=
 github.com/schollz/sqlite3dump v1.3.1/go.mod h1:mzSTjZpJH4zAb1FN3iNlhWPbbdyeBpOaTW0hukyMHyI=
-github.com/shirou/gopsutil/v4 v4.25.8 h1:NnAsw9lN7587WHxjJA9ryDnqhJpFH6A+wagYWTOH970=
-github.com/shirou/gopsutil/v4 v4.25.8/go.mod h1:q9QdMmfAOVIw7a+eF86P7ISEU6ka+NLgkUxlopV4RwI=
+github.com/shirou/gopsutil/v4 v4.26.2 h1:X8i6sicvUFih4BmYIGT1m2wwgw2VG9YgrDTi7cIRGUI=
+github.com/shirou/gopsutil/v4 v4.26.2/go.mod h1:LZ6ewCSkBqUpvSOf+LsTGnRinC6iaNUNMGBtDkJBaLQ=
 github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w=
 github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g=
 github.com/spf13/cobra v0.0.4-0.20190109003409-7547e83b2d85/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
@@ -167,10 +153,10 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/teris-io/shortid v0.0.0-20220617161101-71ec9f2aa569 h1:xzABM9let0HLLqFypcxvLmlvEciCHL7+Lv+4vwZqecI=
 github.com/teris-io/shortid v0.0.0-20220617161101-71ec9f2aa569/go.mod h1:2Ly+NIftZN4de9zRmENdYbvPQeaVIYKWpLFStLFEBgI=
-github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
-github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
-github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
-github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
+github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA=
+github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI=
+github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw=
+github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ=
 github.com/ulikunitz/xz v0.5.11/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/valyala/gozstd v1.20.1 h1:xPnnnvjmaDDitMFfDxmQ4vpx0+3CdTg2o3lALvXTU/g=
 github.com/valyala/gozstd v1.20.1/go.mod h1:y5Ew47GLlP37EkTB+B4s7r6A5rdaeB7ftbl9zoYiIPQ=
@@ -193,8 +179,6 @@ golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliY
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
-golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
 golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
 golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
@@ -202,8 +186,6 @@ golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
-golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
 golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
 golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -217,8 +199,6 @@ golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/net v0.51.0 h1:94R/GTO7mt3/4wIKpcR5gkGmRLOuE/2hNGeWq/GBIFo=
-golang.org/x/net v0.51.0/go.mod h1:aamm+2QF5ogm02fjy5Bb7CQ0WMt1/WVM7FtyaTLlA9Y=
 golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
 golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -245,8 +225,6 @@ golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
 golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
@@ -258,8 +236,8 @@ golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
 golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
-golang.org/x/term v0.41.0 h1:QCgPso/Q3RTJx2Th4bDLqML4W6iJiaXFq2/ftQF13YU=
-golang.org/x/term v0.41.0/go.mod h1:3pfBgksrReYfZ5lvYM0kSO0LIkAl4Yl2bXOkKP7Ec2A=
+golang.org/x/term v0.42.0 h1:UiKe+zDFmJobeJ5ggPwOshJIVt6/Ft0rcfrXZDLWAWY=
+golang.org/x/term v0.42.0/go.mod h1:Dq/D+snpsbazcBG5+F9Q1n2rXV8Ma+71xEjTRufARgY=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
@@ -269,8 +247,6 @@ golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
-golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
-golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
 golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
 golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
 golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
@@ -290,8 +266,9 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntN
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/evanphx/json-patch.v5 v5.9.11 h1:OMPeiLomOQwe8+Ku4nwXsdOmrRw2vGUpP3XgLj3ojNw=
 gopkg.in/evanphx/json-patch.v5 v5.9.11/go.mod h1:/kvTRh1TVm5wuM6OkHxqXtE/1nUZZpihg29RtuIyfvk=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

models/streamOutputVariant.go

@@ -28,6 +28,11 @@ type StreamOutputVariant struct {
 	Framerate int `yaml:"framerate" json:"framerate"`
 	// CPUUsageLevel represents a codec preset to configure CPU usage.
 	CPUUsageLevel int `json:"cpuUsageLevel"`
+
+	// VideoCodec is the video compression format for this variant (e.g., "h264").
+	VideoCodec string `yaml:"videoCodec" json:"videoCodec,omitempty"`
+	// AudioCodec is the audio compression format for this variant (e.g., "aac").
+	AudioCodec string `yaml:"audioCodec" json:"audioCodec,omitempty"`
 }
 
 // GetFramerate returns the framerate or default.

openapi.yaml

@@ -1545,7 +1545,8 @@ paths:
           $ref: '#/components/responses/204'
   /admin/config/video/codec:
     post:
-      summary: Set video codec
+      summary: Set video encoder type
+      description: "Set the global video encoder backend (e.g., software, nvenc, vaapi)."
       operationId: SetVideoCodec
       tags: ['Internal', 'Admin', 'Video']
       security:
@@ -1554,7 +1555,7 @@ paths:
         $ref: '#/components/requestBodies/AdminConfigValue'
       responses:
         '200':
-          description: Video codec updated
+          description: Video encoder updated
           content:
             application/json:
               schema:
@@ -3918,6 +3919,12 @@ components:
           type: integer
         cpuUsageLevel:
           type: integer
+        videoCodec:
+          type: string
+          description: "Video compression format (e.g., h264). Defaults to h264."
+        audioCodec:
+          type: string
+          description: "Audio compression format (e.g., aac). Defaults to aac."
     LatencyLevel:
       type: object
       properties:
@@ -4204,15 +4211,29 @@ components:
           type: string
         webServerIP:
           type: string
-        videoCodec:
+        videoEncoder:
           type: string
+          description: "The global video encoder type (e.g., software, nvenc, vaapi)"
         videoServingEndpoint:
           type: string
         s3:
           $ref: '#/components/schemas/S3Info'
         federation:
           $ref: '#/components/schemas/AdminFederationConfig'
-        supportedCodecs:
+        supportedVideoEncoders:
+          type: array
+          items:
+            type: object
+            properties:
+              encoderType:
+                type: string
+              encoderDisplayName:
+                type: string
+              supportedVideoCodecs:
+                type: array
+                items:
+                  type: string
+        supportedAudioCodecs:
           type: array
           items:
             type: string

persistence/configrepository/configMigrations.go

@@ -9,7 +9,7 @@ import (
 )
 
 const (
-	datastoreValuesVersion   = 4
+	datastoreValuesVersion   = 5
 	datastoreValueVersionKey = "DATA_STORE_VERSION"
 )
 
@@ -30,6 +30,8 @@ func migrateDatastoreValues(datastore *data.Datastore, configRepository ConfigRe
 			migrateToDatastoreValues3ServingEndpoint3(configRepository)
 		case 3:
 			migrateToDatastoreValues4(datastore, configRepository)
+		case 4:
+			migrateToDatastoreValues5(datastore, configRepository)
 		default:
 			log.Fatalln("missing datastore values migration step")
 		}
@@ -86,3 +88,44 @@ func migrateToDatastoreValues4(datastore *data.Datastore, configRepository Confi
 		log.Fatalln("error migrating admin password:", err)
 	}
 }
+
+func migrateToDatastoreValues5(datastore *data.Datastore, configRepository ConfigRepository) {
+	// Migrate the old video_codec value (which was really an encoder name like "libx264",
+	// "h264_nvenc") to the new video_encoder key with the encoder type ("software", "nvenc").
+	// Inlined from transcoder.OldCodecNameToEncoderType to avoid an import cycle
+	// (core/transcoder imports persistence/configrepository).
+	oldCodecToEncoderType := map[string]string{
+		"libx264":           "software",
+		"h264_nvenc":        "nvenc",
+		"h264_vaapi":        "vaapi",
+		"h264_qsv":          "qsv",
+		"h264_omx":          "omx",
+		"h264_v4l2m2m":      "v4l2m2m",
+		"h264_videotoolbox": "videotoolbox",
+	}
+
+	oldCodecValue, _ := datastore.GetString("video_codec")
+	if oldCodecValue != "" {
+		encoderType, ok := oldCodecToEncoderType[oldCodecValue]
+		if !ok {
+			encoderType = "software"
+		}
+		if err := configRepository.SetVideoEncoder(encoderType); err != nil {
+			log.Errorln("error migrating video encoder setting:", err)
+		}
+	}
+
+	// Add default video and audio codec values to existing stream output variants.
+	variants := configRepository.GetStreamOutputVariants()
+	for i := range variants {
+		if variants[i].VideoCodec == "" {
+			variants[i].VideoCodec = "h264"
+		}
+		if variants[i].AudioCodec == "" {
+			variants[i].AudioCodec = "aac"
+		}
+	}
+	if err := configRepository.SetStreamOutputVariants(variants); err != nil {
+		log.Errorln("error migrating stream output variants with codec defaults:", err)
+	}
+}

persistence/configrepository/configkeys.go

@@ -30,7 +30,7 @@ const (
 	externalActionsKey              = "external_actions"
 	customStylesKey                 = "custom_styles"
 	customJavascriptKey             = "custom_javascript"
-	videoCodecKey                   = "video_codec"
+	videoEncoderKey                 = "video_encoder"
 	blockedUsernamesKey             = "blocked_usernames"
 	publicKeyKey                    = "public_key"
 	privateKeyKey                   = "private_key"

persistence/configrepository/configrepository.go

@@ -75,8 +75,8 @@ type ConfigRepository interface {
 	GetCustomStyles() string
 	SetCustomJavascript(styles string) error
 	GetCustomJavascript() string
-	SetVideoCodec(codec string) error
-	GetVideoCodec() string
+	SetVideoEncoder(encoder string) error
+	GetVideoEncoder() string
 	VerifySettings() error
 	FindHighestVideoQualityIndex(qualities []models.StreamOutputVariant) (int, bool)
 	GetForbiddenUsernameList() []string

persistence/configrepository/sqlconfigrepository.go

@@ -623,19 +623,19 @@ func (r *SqlConfigRepository) GetCustomJavascript() string {
 	return style
 }
 
-// SetVideoCodec will set the codec used for video encoding.
-func (r *SqlConfigRepository) SetVideoCodec(codec string) error {
-	return r.datastore.SetString(videoCodecKey, codec)
+// SetVideoEncoder will set the encoder used for video encoding.
+func (r *SqlConfigRepository) SetVideoEncoder(encoder string) error {
+	return r.datastore.SetString(videoEncoderKey, encoder)
 }
 
-// GetVideoCodec returns the codec to use for transcoding video.
-func (r *SqlConfigRepository) GetVideoCodec() string {
-	codec, err := r.datastore.GetString(videoCodecKey)
-	if codec == "" || err != nil {
-		return "libx264" // Default value
+// GetVideoEncoder returns the encoder to use for transcoding video.
+func (r *SqlConfigRepository) GetVideoEncoder() string {
+	encoder, err := r.datastore.GetString(videoEncoderKey)
+	if encoder == "" || err != nil {
+		return "software"
 	}
 
-	return codec
+	return encoder
 }
 
 // VerifySettings will perform a sanity check for specific settings values.

static/static.go

@@ -51,12 +51,20 @@ func GetWebIndexTemplate() (*template.Template, error) {
 	return tmpl, err
 }
 
-//go:embed offline-v2.ts
-var offlineVideoSegment []byte
+//go:embed offline-init.mp4
+var offlineInitSegment []byte
 
-// GetOfflineSegment will return the offline video segment data.
-func GetOfflineSegment() []byte {
-	return getFileSystemStaticFileOrDefault("offline-v2.ts", offlineVideoSegment)
+// GetOfflineInitSegment will return the fMP4 init segment for the offline clip.
+func GetOfflineInitSegment() []byte {
+	return getFileSystemStaticFileOrDefault("offline-init.mp4", offlineInitSegment)
+}
+
+//go:embed offline-v2.m4s
+var offlineMediaSegment []byte
+
+// GetOfflineMediaSegment will return the fMP4 media segment for the offline clip.
+func GetOfflineMediaSegment() []byte {
+	return getFileSystemStaticFileOrDefault("offline-v2.m4s", offlineMediaSegment)
 }
 
 //go:embed img/logo.png

test/automated/tools.sh

@@ -11,24 +11,40 @@ function install_ffmpeg() {
 	fi
 
 	FFMPEG_VER="8.0"
-	FFMPEG_BUILD_VERSION="20251223233512"
+	FFMPEG_BUILD_VERSION="20260223192056"
 	FFMPEG_PATH="$(pwd)"
 	PATH=$FFMPEG_PATH:$PATH
 
+	# Determine the platform-specific archive name
+	ARCH="$(uname -m)"
+	if [[ "$OSTYPE" == "darwin"* ]]; then
+		if [[ "$ARCH" == "arm64" ]]; then
+			FFMPEG_ARCHIVE="ffmpeg${FFMPEG_VER}-darwin-arm64.tar.gz"
+		else
+			FFMPEG_ARCHIVE="ffmpeg${FFMPEG_VER}-darwin-amd64.tar.gz"
+		fi
+	else
+		if [[ "$ARCH" == "aarch64" ]]; then
+			FFMPEG_ARCHIVE="ffmpeg${FFMPEG_VER}-linux-arm64-static.tar.gz"
+		else
+			FFMPEG_ARCHIVE="ffmpeg${FFMPEG_VER}-linux-amd64-static.tar.gz"
+		fi
+	fi
+
 	if [[ -x "$FFMPEG_PATH/ffmpeg" ]]; then
 
 		ffmpeg_version=$("$FFMPEG_PATH/ffmpeg" -version | awk -F 'ffmpeg version' '{print $2}' | awk 'NR==1{print $1}')
 
-		if [[ "$ffmpeg_version" == "$FFMPEG_VER-static" ]]; then
+		if [[ "$ffmpeg_version" == "${FFMPEG_VER}.1" ]]; then
 			return 0
 		else
 			mv "$FFMPEG_PATH/ffmpeg" "$FFMPEG_PATH/ffmpeg.bk" || rm -f "$FFMPEG_PATH/ffmpeg"
 		fi
 	fi
 
-	echo "Downloading ffmpeg v${FFMPEG_VER} release ${FFMPEG_BUILD_VERSION}"
+	echo "Downloading ffmpeg v${FFMPEG_VER} release ${FFMPEG_BUILD_VERSION} (${FFMPEG_ARCHIVE})"
 	rm -rf ffmpeg.tar.gz
-	curl -sL --fail "https://github.com/owncast/ffmpeg-builds/releases/download/${FFMPEG_BUILD_VERSION}/ffmpeg${FFMPEG_VER}-amd64-static.tar.gz" --output ffmpeg.tar.gz >/dev/null
+	curl -sL --fail "https://github.com/owncast/ffmpeg-builds/releases/download/${FFMPEG_BUILD_VERSION}/${FFMPEG_ARCHIVE}" --output ffmpeg.tar.gz >/dev/null
 	tar -xzf ffmpeg.tar.gz
 	rm -f ffmpeg.tar.gz
 	chmod +x ffmpeg

test/ocTestStream.sh

@@ -9,8 +9,8 @@
 # Example: ./test/ocTestStream.sh ~/Downloads/*.mp4 rtmp://127.0.0.1/live/abc123
 
 
-ffmpeg_execs=( 'ffmpeg' 'ffmpeg.exe' )
-ffmpeg_paths=( './' '../' '' )
+ffmpeg_execs=( 'ffmpeg' )
+ffmpeg_paths=( '' './' )
 
 for _ffmpeg_exec in "${ffmpeg_execs[@]}"; do
   for _ffmpeg_path in "${ffmpeg_paths[@]}"; do
@@ -50,7 +50,7 @@ if [[ ${FILE_COUNT} -eq 0 ]]; then
   echo "Streaming internal test video loop to $DESTINATION_HOST"
   echo "...press ctrl+c to exit"
 
-  command "${ffmpeg_exec}" -hide_banner -loglevel panic -nostdin -re -f lavfi \
+  command "${ffmpeg_exec}" -hide_banner -loglevel warning -nostdin -re -f lavfi \
     -i "testsrc=size=1280x720:rate=60[out0];sine=frequency=400:sample_rate=48000[out1]" \
     -vf "[in]drawtext=fontsize=96: box=1: boxcolor=black@0.75: boxborderw=5: fontcolor=white: x=(w-text_w)/2: y=((h-text_h)/2)+((h-text_h)/-2): text='Owncast Test Stream', drawtext=fontsize=96: box=1: boxcolor=black@0.75: boxborderw=5: fontcolor=white: x=(w-text_w)/2: y=((h-text_h)/2)+((h-text_h)/2): text='%{gmtime\:%H\\\\\:%M\\\\\:%S} UTC'[out]" \
     -nal-hrd cbr \

utils/utils.go

@@ -215,23 +215,25 @@ func GetCacheDurationSecondsForPath(filePath string) int {
 
 	defaultDaysCached := 30
 
-	if filename == "thumbnail.jpg" || filename == "preview.gif" {
+	if filename == "thumbnail.jpg" || filename == "preview.gif" || filename == "init.mp4" {
 		// Thumbnails & preview gif re-generate during live
 		return 20
-	} else if fileExtension == ".js" || fileExtension == ".css" {
-		// Cache javascript & CSS
-		return 60 * 60 * 24 * defaultDaysCached
-	} else if fileExtension == ".ts" || fileExtension == ".woff2" {
+	}
+
+	if filename == "/" || fileExtension == "" {
+		return 0
+	}
+
+	switch fileExtension {
+	case ".m3u8", ".html":
+		return 0
+	case ".m4s", ".mp4", ".woff2":
 		// Cache video segments as long as you want. They can't change.
 		// This matters most for local hosting of segments for recordings
 		// and not for live or 3rd party storage.
 		return 31557600
-	} else if fileExtension == ".m3u8" {
-		return 0
-	} else if fileExtension == ".jpg" || fileExtension == ".png" || fileExtension == ".gif" || fileExtension == ".svg" {
+	case ".js", ".css", ".jpg", ".png", ".gif", ".svg":
 		return 60 * 60 * 24 * defaultDaysCached
-	} else if fileExtension == ".html" || filename == "/" || fileExtension == "" {
-		return 0
 	}
 
 	// Default cache length in seconds

web/components/admin/CodecSelector.tsx

@@ -23,20 +23,20 @@ export const CodecSelector: FC<CodecSelectorProps> = () => {
   const { t } = useTranslation();
   const serverStatusData = useContext(ServerStatusContext);
   const { serverConfig, setFieldInConfigState } = serverStatusData || {};
-  const { videoCodec, supportedCodecs } = serverConfig || {};
+  const { videoEncoder, supportedVideoEncoders } = serverConfig || {};
   const { Title } = Typography;
   const { Option } = Select;
   const [submitStatus, setSubmitStatus] = useState<StatusState>(null);
   const { setMessage } = useContext(AlertMessageContext);
-  const [selectedCodec, setSelectedCodec] = useState(videoCodec);
-  const [pendingSaveCodec, setPendingSavecodec] = useState(videoCodec);
+  const [selectedCodec, setSelectedCodec] = useState(videoEncoder);
+  const [pendingSaveCodec, setPendingSaveCodec] = useState(videoEncoder);
   const [confirmPopupOpen, setConfirmPopupOpen] = React.useState(false);
 
   let resetTimer = null;
 
   useEffect(() => {
-    setSelectedCodec(videoCodec);
-  }, [videoCodec]);
+    setSelectedCodec(videoEncoder);
+  }, [videoEncoder]);
 
   const resetStates = () => {
     setSubmitStatus(null);
@@ -45,13 +45,13 @@ export const CodecSelector: FC<CodecSelectorProps> = () => {
   };
 
   function handleChange(value) {
-    setPendingSavecodec(value);
+    setPendingSaveCodec(value);
     setConfirmPopupOpen(true);
   }
 
   async function save() {
     setSelectedCodec(pendingSaveCodec);
-    setPendingSavecodec('');
+    setPendingSaveCodec('');
     setConfirmPopupOpen(false);
 
     await postConfigUpdateToAPI({
@@ -59,9 +59,8 @@ export const CodecSelector: FC<CodecSelectorProps> = () => {
       data: { value: pendingSaveCodec },
       onSuccess: () => {
         setFieldInConfigState({
-          fieldName: 'videoCodec',
+          fieldName: 'videoEncoder',
           value: pendingSaveCodec,
-          path: 'videoSettings',
         });
         setSubmitStatus(
           createInputStatus(STATUS_SUCCESS, t(Localization.Admin.StatusMessages.videoCodecUpdated)),
@@ -70,7 +69,7 @@ export const CodecSelector: FC<CodecSelectorProps> = () => {
         resetTimer = setTimeout(resetStates, RESET_TIMEOUT);
         if (serverStatusData.online) {
           setMessage(
-            'Your latency buffer setting will take effect the next time you begin a live stream.',
+            'Your encoder setting will take effect the next time you begin a live stream.',
           );
         }
       },
@@ -82,50 +81,31 @@ export const CodecSelector: FC<CodecSelectorProps> = () => {
     });
   }
 
-  const items = supportedCodecs.map(codec => {
-    let title = codec;
-    if (title === 'libx264') {
-      title = 'Default (libx264)';
-    } else if (title === 'h264_nvenc') {
-      title = 'NVIDIA GPU acceleration';
-    } else if (title === 'h264_vaapi') {
-      title = 'VA-API hardware encoding';
-    } else if (title === 'h264_qsv') {
-      title = 'Intel QuickSync';
-    } else if (title === 'h264_v4l2m2m') {
-      title = 'Video4Linux hardware encoding';
-    } else if (title === 'h264_omx') {
-      title = 'OpenMax (omx) for Raspberry Pi';
-    } else if (title === 'h264_videotoolbox') {
-      title = 'Apple VideoToolbox (hardware)';
-    }
-
-    return (
-      <Option key={codec} value={codec}>
-        {title}
-      </Option>
-    );
-  });
+  const items = (supportedVideoEncoders || []).map(encoder => (
+    <Option key={encoder.encoderType} value={encoder.encoderType}>
+      {encoder.encoderDisplayName}
+    </Option>
+  ));
 
   let description = '';
-  if (selectedCodec === 'libx264') {
+  if (selectedCodec === 'software') {
     description =
-      'libx264 is the default codec and generally the only working choice for shared VPS environments. This is likely what you should be using unless you know you have set up other options.';
-  } else if (selectedCodec === 'h264_nvenc') {
+      'Software encoding uses your CPU. This is the default and generally the only working choice for shared VPS environments. This is likely what you should be using unless you know you have set up other options.';
+  } else if (selectedCodec === 'nvenc') {
     description =
       'You can use your NVIDIA GPU for encoding if you have a modern NVIDIA card with encoding cores.';
-  } else if (selectedCodec === 'h264_vaapi') {
+  } else if (selectedCodec === 'vaapi') {
     description =
       'VA-API may be supported by your NVIDIA proprietary drivers, Mesa open-source drivers for AMD or Intel graphics.';
-  } else if (selectedCodec === 'h264_qsv') {
+  } else if (selectedCodec === 'qsv') {
     description =
       "Quick Sync Video is Intel's brand for its dedicated video encoding and decoding hardware. It may be an option if you have a modern Intel CPU with integrated graphics.";
-  } else if (selectedCodec === 'h264_v4l2m2m') {
+  } else if (selectedCodec === 'v4l2m2m') {
     description =
       'Video4Linux is an interface to multiple different hardware encoding platforms such as Intel and AMD.';
-  } else if (selectedCodec === 'h264_omx') {
-    description = 'OpenMax is a codec most often used with a Raspberry Pi.';
-  } else if (selectedCodec === 'h264_videotoolbox') {
+  } else if (selectedCodec === 'omx') {
+    description = 'OpenMax is an encoder most often used with a Raspberry Pi.';
+  } else if (selectedCodec === 'videotoolbox') {
     description =
       'Apple VideoToolbox is a low-level framework that provides direct access to hardware encoders and decoders.';
   }
@@ -151,7 +131,7 @@ export const CodecSelector: FC<CodecSelectorProps> = () => {
       </div>
       <div className="segment-slider-container">
         <Popconfirm
-          title={`Are you sure you want to change your video codec to ${pendingSaveCodec} and understand what this means?`}
+          title={`Are you sure you want to change your video encoder to ${pendingSaveCodec} and understand what this means?`}
           open={confirmPopupOpen}
           placement="leftBottom"
           onConfirm={save}

web/public/mockServiceWorker.js

@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '2.11.6'
+const PACKAGE_VERSION = '2.13.2'
 const INTEGRITY_CHECKSUM = '4db4a41e972cec1b64cc569c66952d82'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 const activeClientIds = new Set()

web/types/config-section.ts

@@ -66,6 +66,15 @@ export interface VideoVariant {
   scaledHeight: number;
 
   name: string;
+
+  videoCodec: string;
+  audioCodec: string;
+}
+
+export interface EncoderCodecSupport {
+  encoderType: string;
+  encoderDisplayName: string;
+  supportedVideoCodecs: string[];
 }
 export interface VideoSettingsFields {
   latencyLevel: number;
@@ -147,8 +156,9 @@ export interface ConfigDetails {
   socketHostOverride: string;
   videoServingEndpoint: string;
   yp: ConfigDirectoryFields;
-  supportedCodecs: string[];
-  videoCodec: string;
+  supportedVideoEncoders: EncoderCodecSupport[];
+  supportedAudioCodecs: string[];
+  videoEncoder: string;
   forbiddenUsernames: string[];
   suggestedUsernames: string[];
   chatDisabled: boolean;

web/utils/config-constants.tsx

@@ -251,6 +251,8 @@ export const DEFAULT_VARIANT_STATE: VideoVariant = {
   scaledHeight: null,
   scaledWidth: null,
   name: '',
+  videoCodec: '',
+  audioCodec: '',
 };
 
 export const FIELD_PROPS_DISABLE_CHAT = {

web/utils/server-status-context.tsx

@@ -64,8 +64,9 @@ const initialServerConfigState: ConfigDetails = {
     discord: { enabled: false, webhook: '', goLiveMessage: '' },
   },
   externalActions: [],
-  supportedCodecs: [],
-  videoCodec: '',
+  supportedVideoEncoders: [],
+  supportedAudioCodecs: [],
+  videoEncoder: '',
   forbiddenUsernames: [],
   suggestedUsernames: [],
   chatDisabled: false,

webserver/handlers/admin/config.go

@@ -740,7 +740,9 @@ func SetChatDisabled(w http.ResponseWriter, r *http.Request) {
 	webutils.WriteSimpleResponse(w, true, "chat disabled status updated")
 }
 
-// SetVideoCodec will change the codec used for video encoding.
+// SetVideoCodec will change the encoder used for video encoding.
+// The endpoint name is kept for backward compatibility but the value
+// is now an encoder type (e.g., "software", "nvenc") not an ffmpeg codec name.
 func SetVideoCodec(w http.ResponseWriter, r *http.Request) {
 	if !requirePOST(w, r) {
 		return
@@ -748,17 +750,17 @@ func SetVideoCodec(w http.ResponseWriter, r *http.Request) {
 
 	configValue, success := getValueFromRequest(w, r)
 	if !success {
-		webutils.WriteSimpleResponse(w, false, "unable to change video codec")
+		webutils.WriteSimpleResponse(w, false, "unable to change video encoder")
 		return
 	}
 
 	configRepository := configrepository.Get()
-	if err := configRepository.SetVideoCodec(configValue.Value.(string)); err != nil {
-		webutils.WriteSimpleResponse(w, false, "unable to update codec")
+	if err := configRepository.SetVideoEncoder(configValue.Value.(string)); err != nil {
+		webutils.WriteSimpleResponse(w, false, "unable to update video encoder")
 		return
 	}
 
-	webutils.WriteSimpleResponse(w, true, "video codec updated")
+	webutils.WriteSimpleResponse(w, true, "video encoder updated")
 }
 
 // SetExternalActions will set the 3rd party actions for the web interface.

webserver/handlers/admin/serverConfig.go

@@ -34,6 +34,8 @@ func GetServerConfig(w http.ResponseWriter, r *http.Request) {
 			CPUUsageLevel:      variant.CPUUsageLevel,
 			ScaledWidth:        variant.ScaledWidth,
 			ScaledHeight:       variant.ScaledHeight,
+			VideoCodec:         variant.VideoCodec,
+			AudioCodec:         variant.AudioCodec,
 		})
 	}
 	response := serverConfigAdminResponse{
@@ -77,12 +79,13 @@ func GetServerConfig(w http.ResponseWriter, r *http.Request) {
 			Enabled:     configRepository.GetDirectoryEnabled(),
 			InstanceURL: configRepository.GetServerURL(),
 		},
-		S3:                 configRepository.GetS3Config(),
-		ExternalActions:    configRepository.GetExternalActions(),
-		SupportedCodecs:    transcoder.GetCodecs(ffmpeg),
-		VideoCodec:         configRepository.GetVideoCodec(),
-		ForbiddenUsernames: usernameBlocklist,
-		SuggestedUsernames: usernameSuggestions,
+		S3:                     configRepository.GetS3Config(),
+		ExternalActions:        configRepository.GetExternalActions(),
+		SupportedVideoEncoders: transcoder.GetAvailableVideoEncoders(ffmpeg),
+		SupportedAudioCodecs:   transcoder.GetAvailableAudioCodecs(ffmpeg),
+		VideoEncoder:           configRepository.GetVideoEncoder(),
+		ForbiddenUsernames:     usernameBlocklist,
+		SuggestedUsernames:     usernameSuggestions,
 		Federation: federationConfigResponse{
 			Enabled:        configRepository.GetFederationEnabled(),
 			IsPrivate:      configRepository.GetFederationIsPrivate(),
@@ -106,34 +109,35 @@ func GetServerConfig(w http.ResponseWriter, r *http.Request) {
 }
 
 type serverConfigAdminResponse struct {
-	InstanceDetails           webConfigResponse           `json:"instanceDetails"`
-	Notifications             notificationsConfigResponse `json:"notifications"`
-	YP                        yp                          `json:"yp"`
-	FFmpegPath                string                      `json:"ffmpegPath"`
-	AdminPassword             string                      `json:"adminPassword"`
-	SocketHostOverride        string                      `json:"socketHostOverride,omitempty"`
-	WebServerIP               string                      `json:"webServerIP"`
-	VideoCodec                string                      `json:"videoCodec"`
-	VideoServingEndpoint      string                      `json:"videoServingEndpoint"`
-	S3                        models.S3                   `json:"s3"`
-	Federation                federationConfigResponse    `json:"federation"`
-	SupportedCodecs           []string                    `json:"supportedCodecs"`
-	ExternalActions           []models.ExternalAction     `json:"externalActions"`
-	ForbiddenUsernames        []string                    `json:"forbiddenUsernames"`
-	SuggestedUsernames        []string                    `json:"suggestedUsernames"`
-	StreamKeys                []generated.StreamKey       `json:"streamKeys"`
-	VideoSettings             videoSettings               `json:"videoSettings"`
-	RTMPServerPort            int                         `json:"rtmpServerPort"`
-	WebServerPort             int                         `json:"webServerPort"`
-	ChatDisabled              bool                        `json:"chatDisabled"`
-	ChatJoinMessagesEnabled   bool                        `json:"chatJoinMessagesEnabled"`
-	ChatEstablishedUserMode   bool                        `json:"chatEstablishedUserMode"`
-	ChatSpamProtectionEnabled bool                        `json:"chatSpamProtectionEnabled"`
-	ChatSlurFilterEnabled     bool                        `json:"chatSlurFilterEnabled"`
-	ChatRequireAuthentication bool                        `json:"chatRequireAuthentication"`
-	DisableSearchIndexing     bool                        `json:"disableSearchIndexing"`
-	StreamKeyOverridden       bool                        `json:"streamKeyOverridden"`
-	HideViewerCount           bool                        `json:"hideViewerCount"`
+	InstanceDetails           webConfigResponse                `json:"instanceDetails"`
+	Notifications             notificationsConfigResponse      `json:"notifications"`
+	YP                        yp                               `json:"yp"`
+	FFmpegPath                string                           `json:"ffmpegPath"`
+	AdminPassword             string                           `json:"adminPassword"`
+	SocketHostOverride        string                           `json:"socketHostOverride,omitempty"`
+	WebServerIP               string                           `json:"webServerIP"`
+	VideoEncoder              string                           `json:"videoEncoder"`
+	VideoServingEndpoint      string                           `json:"videoServingEndpoint"`
+	S3                        models.S3                        `json:"s3"`
+	Federation                federationConfigResponse         `json:"federation"`
+	SupportedVideoEncoders    []transcoder.EncoderCodecSupport `json:"supportedVideoEncoders"`
+	SupportedAudioCodecs      []string                         `json:"supportedAudioCodecs"`
+	ExternalActions           []models.ExternalAction          `json:"externalActions"`
+	ForbiddenUsernames        []string                         `json:"forbiddenUsernames"`
+	SuggestedUsernames        []string                         `json:"suggestedUsernames"`
+	StreamKeys                []generated.StreamKey            `json:"streamKeys"`
+	VideoSettings             videoSettings                    `json:"videoSettings"`
+	RTMPServerPort            int                              `json:"rtmpServerPort"`
+	WebServerPort             int                              `json:"webServerPort"`
+	ChatDisabled              bool                             `json:"chatDisabled"`
+	ChatJoinMessagesEnabled   bool                             `json:"chatJoinMessagesEnabled"`
+	ChatEstablishedUserMode   bool                             `json:"chatEstablishedUserMode"`
+	ChatSpamProtectionEnabled bool                             `json:"chatSpamProtectionEnabled"`
+	ChatSlurFilterEnabled     bool                             `json:"chatSlurFilterEnabled"`
+	ChatRequireAuthentication bool                             `json:"chatRequireAuthentication"`
+	DisableSearchIndexing     bool                             `json:"disableSearchIndexing"`
+	StreamKeyOverridden       bool                             `json:"streamKeyOverridden"`
+	HideViewerCount           bool                             `json:"hideViewerCount"`
 }
 
 type videoSettings struct {

webserver/handlers/generated/generated-types.gen.go

@@ -105,13 +105,20 @@ type AdminServerConfig struct {
 	StreamKeyOverridden     *bool                     `json:"streamKeyOverridden,omitempty"`
 	StreamKeys              *[]StreamKey              `json:"streamKeys,omitempty"`
 	SuggestedUsernames      *[]string                 `json:"suggestedUsernames,omitempty"`
-	SupportedCodecs         *[]string                 `json:"supportedCodecs,omitempty"`
-	VideoCodec              *string                   `json:"videoCodec,omitempty"`
-	VideoServingEndpoint    *string                   `json:"videoServingEndpoint,omitempty"`
-	VideoSettings           *AdminVideoSettings       `json:"videoSettings,omitempty"`
-	WebServerIP             *string                   `json:"webServerIP,omitempty"`
-	WebServerPort           *int                      `json:"webServerPort,omitempty"`
-	Yp                      *AdminYPInfo              `json:"yp,omitempty"`
+	SupportedAudioCodecs    *[]string                 `json:"supportedAudioCodecs,omitempty"`
+	SupportedVideoEncoders  *[]struct {
+		EncoderDisplayName   *string   `json:"encoderDisplayName,omitempty"`
+		EncoderType          *string   `json:"encoderType,omitempty"`
+		SupportedVideoCodecs *[]string `json:"supportedVideoCodecs,omitempty"`
+	} `json:"supportedVideoEncoders,omitempty"`
+
+	// VideoEncoder The global video encoder type (e.g., software, nvenc, vaapi)
+	VideoEncoder         *string             `json:"videoEncoder,omitempty"`
+	VideoServingEndpoint *string             `json:"videoServingEndpoint,omitempty"`
+	VideoSettings        *AdminVideoSettings `json:"videoSettings,omitempty"`
+	WebServerIP          *string             `json:"webServerIP,omitempty"`
+	WebServerPort        *int                `json:"webServerPort,omitempty"`
+	Yp                   *AdminYPInfo        `json:"yp,omitempty"`
 }
 
 // AdminStatus defines model for AdminStatus.
@@ -493,7 +500,10 @@ type StreamKey struct {
 
 // StreamOutputVariant defines model for StreamOutputVariant.
 type StreamOutputVariant struct {
-	AudioBitrate     *int    `json:"audioBitrate,omitempty"`
+	AudioBitrate *int `json:"audioBitrate,omitempty"`
+
+	// AudioCodec Audio compression format (e.g., aac). Defaults to aac.
+	AudioCodec       *string `json:"audioCodec,omitempty"`
 	AudioPassthrough *bool   `json:"audioPassthrough,omitempty"`
 	CpuUsageLevel    *int    `json:"cpuUsageLevel,omitempty"`
 	Framerate        *int    `json:"framerate,omitempty"`
@@ -501,6 +511,9 @@ type StreamOutputVariant struct {
 	ScaledHeight     *int    `json:"scaledHeight,omitempty"`
 	ScaledWidth      *int    `json:"scaledWidth,omitempty"`
 	VideoBitrate     *int    `json:"videoBitrate,omitempty"`
+
+	// VideoCodec Video compression format (e.g., h264). Defaults to h264.
+	VideoCodec       *string `json:"videoCodec,omitempty"`
 	VideoPassthrough *bool   `json:"videoPassthrough,omitempty"`
 }
 

webserver/handlers/hls.go

@@ -18,7 +18,8 @@ import (
 // HandleHLSRequest will manage all requests to HLS content.
 func HandleHLSRequest(w http.ResponseWriter, r *http.Request) {
 	// Sanity check to limit requests to HLS file types.
-	if filepath.Ext(r.URL.Path) != ".m3u8" && filepath.Ext(r.URL.Path) != ".ts" {
+	ext := filepath.Ext(r.URL.Path)
+	if ext != ".m3u8" && ext != ".m4s" && ext != ".mp4" {
 		w.WriteHeader(http.StatusNotFound)
 		return
 	}