Added per-codec bitstream filter support to audio codecs.

Added codec-aware encoding profiles and moved pixel format to per-variant output.
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.
2026-04-04 19:49:37 -04:00 · 2026-04-04 14:50:29 -04:00 · 2026-04-04 14:11:49 -04:00
33 changed files with 1240 additions and 703 deletions
@@ -93,6 +93,8 @@ func GetDefaults() Defaults {
 				VideoBitrate:       1200,
 				Framerate:          24,
 				CPUUsageLevel:      2,
 				VideoCodec:         "h264",
 				AudioCodec:         "aac",
 			},
 		},
@@ -0,0 +1,49 @@
 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
 	BitstreamFilters() []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
 }
 func (c *AACCodec) BitstreamFilters() []string {
 	return []string{
 		// "aac_adtstoasc", // Required for fMP4 segments, not needed yet.
 	}
 }
 var audioCodecRegistry = map[string]AudioCodec{
 	audioCodecAAC: &AACCodec{},
 }
 func getAudioCodec(name string) AudioCodec {
 	if codec, ok := audioCodecRegistry[name]; ok {
 		return codec
 	}
 	return &AACCodec{}
 }
@@ -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{}
 	}
 }
@@ -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
 }
@@ -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{}
 }
@@ -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
 }
@@ -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
 }
@@ -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
 }
@@ -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
 }
@@ -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
 }
@@ -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
 }
@@ -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
@@ -247,11 +250,10 @@ func (t *Transcoder) getFlags() *execInfo {
 	ffmpegFlags = append(ffmpegFlags, []string{
 		"-segment_format_options", "mpegts_flags=mpegts_copyts=1",
 	}...)
-	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
@@ -278,6 +280,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 +323,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 +342,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() != "" {
+		if profile.ExtraFilters != "" {
-			filters = append(filters, t.codec.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 +422,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,13 +469,17 @@ func (v *HLSVariant) getAudioQualityString() []string {
 		}
 	}
-	// libfdk_aac is not a part of every ffmpeg install, so use "aac" instead
+	flags := []string{
 	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,
 	}
 	for _, bsf := range v.audioCodec.BitstreamFilters() {
 		flags = append(flags, fmt.Sprintf("-bsf:a:%d", v.index), bsf)
 	}
 	return flags
 }
 // AddVariant adds a new HLS variant to include in the output.
@@ -495,7 +513,7 @@ func (t *Transcoder) SetInternalHTTPPort(port string) {
 	t.internalListenerPort = port
 }
-// SetCodec will set the codec to be used for the transocder.
+// SetEncoder will set the encoder to be used for the transcoder.
-func (t *Transcoder) SetCodec(codecName string) {
+func (t *Transcoder) SetEncoder(encoderType string) {
-	t.codec = getCodec(codecName)
+	t.encoder = getEncoder(encoderType)
 }
@@ -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 -segment_format_options mpegts_flags=mpegts_copyts=1 -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`
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)
@@ -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 -segment_format_options mpegts_flags=mpegts_copyts=1 -tune zerolatency -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`
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)
@@ -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 -segment_format_options mpegts_flags=mpegts_copyts=1 -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`
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)
@@ -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 -segment_format_options mpegts_flags=mpegts_copyts=1 -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`
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)
@@ -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 -segment_format_options mpegts_flags=mpegts_copyts=1 -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`
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)
@@ -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 -segment_format_options mpegts_flags=mpegts_copyts=1 -tune zerolatency -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`
 	if cmd != expected {
 		t.Errorf("ffmpeg command does not match expected.\nGot %s\n, want: %s", cmd, expected)
@@ -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{}
 }
@@ -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.
@@ -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
@@ -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)
 	}
 }
@@ -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"
@@ -75,8 +75,8 @@ type ConfigRepository interface {
 	GetCustomStyles() string
 	SetCustomJavascript(styles string) error
 	GetCustomJavascript() string
-	SetVideoCodec(codec string) error
+	SetVideoEncoder(encoder string) error
-	GetVideoCodec() string
+	GetVideoEncoder() string
 	VerifySettings() error
 	FindHighestVideoQualityIndex(qualities []models.StreamOutputVariant) (int, bool)
 	GetForbiddenUsernameList() []string
@@ -623,19 +623,19 @@ func (r *SqlConfigRepository) GetCustomJavascript() string {
 	return style
 }
-// SetVideoCodec will set the codec used for video encoding.
+// SetVideoEncoder will set the encoder used for video encoding.
-func (r *SqlConfigRepository) SetVideoCodec(codec string) error {
+func (r *SqlConfigRepository) SetVideoEncoder(encoder string) error {
-	return r.datastore.SetString(videoCodecKey, codec)
+	return r.datastore.SetString(videoEncoderKey, encoder)
 }
-// GetVideoCodec returns the codec to use for transcoding video.
+// GetVideoEncoder returns the encoder to use for transcoding video.
-func (r *SqlConfigRepository) GetVideoCodec() string {
+func (r *SqlConfigRepository) GetVideoEncoder() string {
-	codec, err := r.datastore.GetString(videoCodecKey)
+	encoder, err := r.datastore.GetString(videoEncoderKey)
-	if codec == "" || err != nil {
+	if encoder == "" || err != nil {
-		return "libx264" // Default value
+		return "software"
 	}
-	return codec
+	return encoder
 }
 // VerifySettings will perform a sanity check for specific settings values.
@@ -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 [selectedCodec, setSelectedCodec] = useState(videoEncoder);
-  const [pendingSaveCodec, setPendingSavecodec] = useState(videoCodec);
+  const [pendingSaveCodec, setPendingSaveCodec] = useState(videoEncoder);
  const [confirmPopupOpen, setConfirmPopupOpen] = React.useState(false);
  let resetTimer = null;
  useEffect(() => {
-    setSelectedCodec(videoCodec);
+    setSelectedCodec(videoEncoder);
-  }, [videoCodec]);
+  }, [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 => {
+  const items = (supportedVideoEncoders || []).map(encoder => (
-    let title = codec;
+    <Option key={encoder.encoderType} value={encoder.encoderType}>
-    if (title === 'libx264') {
+      {encoder.encoderDisplayName}
-      title = 'Default (libx264)';
+    </Option>
-    } 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>
    );
  });
  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.';
+      '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 === 'h264_nvenc') {
+  } 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') {
+  } else if (selectedCodec === 'omx') {
-    description = 'OpenMax is a codec most often used with a Raspberry Pi.';
+    description = 'OpenMax is an encoder most often used with a Raspberry Pi.';
-  } else if (selectedCodec === 'h264_videotoolbox') {
+  } 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}
@@ -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[];
+  supportedVideoEncoders: EncoderCodecSupport[];
-  videoCodec: string;
+  supportedAudioCodecs: string[];
  videoEncoder: string;
  forbiddenUsernames: string[];
  suggestedUsernames: string[];
  chatDisabled: boolean;
@@ -251,6 +251,8 @@ export const DEFAULT_VARIANT_STATE: VideoVariant = {
  scaledHeight: null,
  scaledWidth: null,
  name: '',
  videoCodec: '',
  audioCodec: '',
 };
 export const FIELD_PROPS_DISABLE_CHAT = {
@@ -64,8 +64,9 @@ const initialServerConfigState: ConfigDetails = {
    discord: { enabled: false, webhook: '', goLiveMessage: '' },
  },
  externalActions: [],
-  supportedCodecs: [],
+  supportedVideoEncoders: [],
-  videoCodec: '',
+  supportedAudioCodecs: [],
  videoEncoder: '',
  forbiddenUsernames: [],
  suggestedUsernames: [],
  chatDisabled: false,
@@ -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 {
+	if err := configRepository.SetVideoEncoder(configValue.Value.(string)); err != nil {
-		webutils.WriteSimpleResponse(w, false, "unable to update codec")
+		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.
@@ -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(),
+		S3:                     configRepository.GetS3Config(),
-		ExternalActions:    configRepository.GetExternalActions(),
+		ExternalActions:        configRepository.GetExternalActions(),
-		SupportedCodecs:    transcoder.GetCodecs(ffmpeg),
+		SupportedVideoEncoders: transcoder.GetAvailableVideoEncoders(ffmpeg),
-		VideoCodec:         configRepository.GetVideoCodec(),
+		SupportedAudioCodecs:   transcoder.GetAvailableAudioCodecs(ffmpeg),
-		ForbiddenUsernames: usernameBlocklist,
+		VideoEncoder:           configRepository.GetVideoEncoder(),
-		SuggestedUsernames: usernameSuggestions,
+		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"`
+	InstanceDetails           webConfigResponse                `json:"instanceDetails"`
-	Notifications             notificationsConfigResponse `json:"notifications"`
+	Notifications             notificationsConfigResponse      `json:"notifications"`
-	YP                        yp                          `json:"yp"`
+	YP                        yp                               `json:"yp"`
-	FFmpegPath                string                      `json:"ffmpegPath"`
+	FFmpegPath                string                           `json:"ffmpegPath"`
-	AdminPassword             string                      `json:"adminPassword"`
+	AdminPassword             string                           `json:"adminPassword"`
-	SocketHostOverride        string                      `json:"socketHostOverride,omitempty"`
+	SocketHostOverride        string                           `json:"socketHostOverride,omitempty"`
-	WebServerIP               string                      `json:"webServerIP"`
+	WebServerIP               string                           `json:"webServerIP"`
-	VideoCodec                string                      `json:"videoCodec"`
+	VideoEncoder              string                           `json:"videoEncoder"`
-	VideoServingEndpoint      string                      `json:"videoServingEndpoint"`
+	VideoServingEndpoint      string                           `json:"videoServingEndpoint"`
-	S3                        models.S3                   `json:"s3"`
+	S3                        models.S3                        `json:"s3"`
-	Federation                federationConfigResponse    `json:"federation"`
+	Federation                federationConfigResponse         `json:"federation"`
-	SupportedCodecs           []string                    `json:"supportedCodecs"`
+	SupportedVideoEncoders    []transcoder.EncoderCodecSupport `json:"supportedVideoEncoders"`
-	ExternalActions           []models.ExternalAction     `json:"externalActions"`
+	SupportedAudioCodecs      []string                         `json:"supportedAudioCodecs"`
-	ForbiddenUsernames        []string                    `json:"forbiddenUsernames"`
+	ExternalActions           []models.ExternalAction          `json:"externalActions"`
-	SuggestedUsernames        []string                    `json:"suggestedUsernames"`
+	ForbiddenUsernames        []string                         `json:"forbiddenUsernames"`
-	StreamKeys                []generated.StreamKey       `json:"streamKeys"`
+	SuggestedUsernames        []string                         `json:"suggestedUsernames"`
-	VideoSettings             videoSettings               `json:"videoSettings"`
+	StreamKeys                []generated.StreamKey            `json:"streamKeys"`
-	RTMPServerPort            int                         `json:"rtmpServerPort"`
+	VideoSettings             videoSettings                    `json:"videoSettings"`
-	WebServerPort             int                         `json:"webServerPort"`
+	RTMPServerPort            int                              `json:"rtmpServerPort"`
-	ChatDisabled              bool                        `json:"chatDisabled"`
+	WebServerPort             int                              `json:"webServerPort"`
-	ChatJoinMessagesEnabled   bool                        `json:"chatJoinMessagesEnabled"`
+	ChatDisabled              bool                             `json:"chatDisabled"`
-	ChatEstablishedUserMode   bool                        `json:"chatEstablishedUserMode"`
+	ChatJoinMessagesEnabled   bool                             `json:"chatJoinMessagesEnabled"`
-	ChatSpamProtectionEnabled bool                        `json:"chatSpamProtectionEnabled"`
+	ChatEstablishedUserMode   bool                             `json:"chatEstablishedUserMode"`
-	ChatSlurFilterEnabled     bool                        `json:"chatSlurFilterEnabled"`
+	ChatSpamProtectionEnabled bool                             `json:"chatSpamProtectionEnabled"`
-	ChatRequireAuthentication bool                        `json:"chatRequireAuthentication"`
+	ChatSlurFilterEnabled     bool                             `json:"chatSlurFilterEnabled"`
-	DisableSearchIndexing     bool                        `json:"disableSearchIndexing"`
+	ChatRequireAuthentication bool                             `json:"chatRequireAuthentication"`
-	StreamKeyOverridden       bool                        `json:"streamKeyOverridden"`
+	DisableSearchIndexing     bool                             `json:"disableSearchIndexing"`
-	HideViewerCount           bool                        `json:"hideViewerCount"`
+	StreamKeyOverridden       bool                             `json:"streamKeyOverridden"`
 	HideViewerCount           bool                             `json:"hideViewerCount"`
 }
 type videoSettings struct {
@@ -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"`
+	SupportedAudioCodecs    *[]string                 `json:"supportedAudioCodecs,omitempty"`
-	VideoCodec              *string                   `json:"videoCodec,omitempty"`
+	SupportedVideoEncoders  *[]struct {
-	VideoServingEndpoint    *string                   `json:"videoServingEndpoint,omitempty"`
+		EncoderDisplayName   *string   `json:"encoderDisplayName,omitempty"`
-	VideoSettings           *AdminVideoSettings       `json:"videoSettings,omitempty"`
+		EncoderType          *string   `json:"encoderType,omitempty"`
-	WebServerIP             *string                   `json:"webServerIP,omitempty"`
+		SupportedVideoCodecs *[]string `json:"supportedVideoCodecs,omitempty"`
-	WebServerPort           *int                      `json:"webServerPort,omitempty"`
+	} `json:"supportedVideoEncoders,omitempty"`
-	Yp                      *AdminYPInfo              `json:"yp,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"`
 }
Author	SHA1	Message	Date
LogalDeveloper	8d7a47293c	Added per-codec bitstream filter support to audio codecs.	2026-04-04 19:49:37 -04:00
LogalDeveloper	46b9c8bd2e	Added codec-aware encoding profiles and moved pixel format to per-variant output. 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.	2026-04-04 14:50:29 -04:00
LogalDeveloper	50e14adac2	Rearchitected transcoding to treat codecs and encoders as separate concepts. ActivityPub Tests / federation-test (push) Failing after 4s ActivityPub Tests / chat-sanitization-test (push) Failing after 3s ActivityPub Tests / follower-validation-test (push) Failing after 4s Extract Default Translations / extract-and-commit (push) Successful in 4m21s Automated API tests / test (push) Has been cancelled Browser Tests / cypress-run (push) Has been cancelled Chromatic / chromatic-deployment (push) Has been cancelled CSS Lint and Formatting / css-lint (push) Has been cancelled javascript-packages / Generate API Documentation (push) Has been cancelled Lint / Go linter (push) Has been cancelled Go Tests / test (push) Has been cancelled Go Tests / test-bsds (map[name:freebsd version:12.2]) (push) Has been cancelled Go Tests / test-bsds (map[name:openbsd version:6.8]) (push) Has been cancelled HLS tests / tests (push) Has been cancelled	2026-04-04 14:11:49 -04:00