ffmpeg

cliapps/ffmpeg/options.go

@@ -1,67 +1,125 @@
 package ffmpeg
 
-import "strconv"
+import (
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+func OptionFilter(options ...Option) []Option {
+	cache := make(map[reflect.Type]Option)
+	for _, option := range options {
+		t := reflect.TypeOf(option)
+		cache[t] = option
+	}
+	var result []Option
+	for _, option := range cache {
+		result = append(result, option)
+	}
+	return result
+}
 
 type Option interface {
 	Option() string
 }
 
-type VideoEncoder string
+// VideoBitrate the bitrate of the video
+type VideoBitrate int
 
-func (v VideoEncoder) Option() string {
-	return string(v)
+func (b VideoBitrate) Option() string {
+	intB := int(b)
+	if intB <= 0 {
+		panic("VideoBitrate must be greater than 0")
+	}
+	s := strings.Builder{}
+	s.WriteString(`-b:v `)
+	s.WriteString(strconv.Itoa(intB))
+	return s.String()
 }
 
-type H264CRF int
+// AudioBitrate the bitrate of the audio
+type AudioBitrate int
+
+func (b AudioBitrate) Option() string {
+	intB := int(b)
+	if intB <= 0 {
+		panic("AudioBitrate must be greater than 0")
+	}
+	s := strings.Builder{}
+	s.WriteString(`-b:a `)
+	s.WriteString(strconv.Itoa(intB))
+	return s.String()
+}
 
-func (c H264CRF) Option() string {
+// CustomOption a custom option that can be used to pass any option to ffmpeg
+type CustomOption string
+
+func (o CustomOption) Option() string {
+	return string(o)
+}
+
+type CRF int
+
+func (c CRF) Option() string {
 	intC := int(c)
 	if intC < 0 || intC > 51 {
-		panic("H264CRF must be between 0 and 51")
+		panic("CRF must be between 0 and 51")
 	}
-	return strconv.Itoa(intC)
+	s := strings.Builder{}
+	s.WriteString(`-crf `)
+	s.WriteString(strconv.Itoa(intC))
+	return s.String()
 }
 
-type H264Preset string
+type Preset string
 
-func (p H264Preset) Option() string {
-	return string(p)
+func (p Preset) Option() string {
+	s := strings.Builder{}
+	s.WriteString(`-preset `)
+	s.WriteString(string(p))
+	return s.String()
 }
 
 const (
-	H264PresetUltrafast H264Preset = `ultrafast`
-	H264PresetSuperfast H264Preset = `superfast`
-	H264PresetVeryfast  H264Preset = `veryfast`
-	H264PresetFaster    H264Preset = `faster`
-	H264PresetFast      H264Preset = `fast`
-	H264PresetMedium    H264Preset = `medium`
-	H264PresetSlow      H264Preset = `slow`
-	H264PresetSlower    H264Preset = `slower`
-	H264PresetVeryslow  H264Preset = `veryslow`
-	H264PresetPlacebo   H264Preset = `placebo`
+	PresetUltrafast Preset = `ultrafast`
+	PresetSuperfast Preset = `superfast`
+	PresetVeryfast  Preset = `veryfast`
+	PresetFaster    Preset = `faster`
+	PresetFast      Preset = `fast`
+	PresetMedium    Preset = `medium`
+	PresetSlow      Preset = `slow`
+	PresetSlower    Preset = `slower`
+	PresetVeryslow  Preset = `veryslow`
+	PresetPlacebo   Preset = `placebo`
 )
 
-type H264Tune string
+type Tune string
 
-func (t H264Tune) Option() string {
-	return string(t)
+func (t Tune) Option() string {
+	s := strings.Builder{}
+	s.WriteString(`-tune `)
+	s.WriteString(string(t))
+	return s.String()
 }
 
 const (
-	H264TuneFilm        H264Tune = `film`
-	H264TuneAnimation   H264Tune = `animation`
-	H264TuneGrain       H264Tune = `grain`
-	H264TuneStillimage  H264Tune = `stillimage`
-	H264TunePsnr        H264Tune = `psnr`
-	H264TuneSsim        H264Tune = `ssim`
-	H264TuneFastdecode  H264Tune = `fastdecode`
-	H264TuneZerolatency H264Tune = `zerolatency`
+	TuneFilm        Tune = `film`
+	TuneAnimation   Tune = `animation`
+	TuneGrain       Tune = `grain`
+	TuneStillimage  Tune = `stillimage`
+	TunePsnr        Tune = `psnr`
+	TuneSsim        Tune = `ssim`
+	TuneFastdecode  Tune = `fastdecode`
+	TuneZerolatency Tune = `zerolatency`
 )
 
 type H264Profile string
 
 func (p H264Profile) Option() string {
-	return string(p)
+	s := strings.Builder{}
+	s.WriteString(`-profile:v `)
+	s.WriteString(string(p))
+	return s.String()
 }
 
 const (
@@ -73,8 +131,47 @@ const (
 	H264ProfileHigh444  H264Profile = `high444`
 )
 
-type CustomOption string
+type H265Quality string
 
-func (o CustomOption) Option() string {
-	return string(o)
+func (h H265Quality) Option() string {
+	return string(h)
 }
+
+const (
+	H265QualityLossless = `-x265-params lossless=1`
+)
+
+type AMFQuality string
+
+func (a AMFQuality) Option() string {
+	s := strings.Builder{}
+	s.WriteString(`-quality `)
+	s.WriteString(string(a))
+	return s.String()
+}
+
+const (
+	AMFQualitySpeed    = `speed`
+	AMFQualityBalanced = `balanced`
+	AMFQualityQuality  = `quality`
+)
+
+type Accelerator string
+
+func (a Accelerator) Option() string {
+	s := strings.Builder{}
+	s.WriteString(`-hwaccel `)
+	s.WriteString(string(a))
+	return s.String()
+}
+
+const (
+	AcceleratorCuda    = `cuda`
+	AcceleratorVaapi   = `vaapi`
+	AcceleratorDxva2   = `dxva2`
+	AcceleratorQsv     = `qsv`
+	AcceleratorD3d11va = `d3d11va`
+	AcceleratorOpencl  = `opencl`
+	AcceleratorVulkan  = `vulkan`
+	AcceleratorD3d12va = `d3d12va`
+)

cliapps/ffmpeg/options_encoders.go

@@ -0,0 +1,91 @@
+package ffmpeg
+
+import "strings"
+
+type VideoEncoder string
+
+func (v VideoEncoder) Option() string {
+	s := strings.Builder{}
+	s.WriteString(`-c:v `)
+	s.WriteString(string(v))
+	return s.String()
+}
+
+// Video encoders
+
+const (
+	VideoEncoderCopy VideoEncoder = `copy`
+)
+
+// Software
+const (
+	VideoEncoderLibx264 VideoEncoder = `libx264`
+	VideoEncoderLibx265 VideoEncoder = `libx265`
+	VideoEncoderLibvpx  VideoEncoder = `libvpx`
+	VideoEncoderLibvpx9 VideoEncoder = `libvpx-vp9`
+	VideoEncoderLibaom  VideoEncoder = `libaom-av1`
+)
+
+// Nvidia GPUS
+const (
+	VideoEncoderH264Nvenc VideoEncoder = `h264_nvenc`
+	VideoEncoderH265Nvenc VideoEncoder = `hevc_nvenc`
+	VideoEncoderVp8Nvenc  VideoEncoder = `vp8_nvenc`
+	VideoEncoderVp9Nvenc  VideoEncoder = `vp9_nvenc`
+	VideoEncoderAv1Nvenc  VideoEncoder = `av1_nvenc`
+)
+
+// Intel GPUS
+const (
+	VideoEncoderH264Qsv VideoEncoder = `h264_qsv`
+	VideoEncoderH265Qsv VideoEncoder = `hevc_qsv`
+	VideoEncnoderVp8Qsv VideoEncoder = `vp8_qsv`
+	VideoEncoderVp9Qsv  VideoEncoder = `vp9_qsv`
+	VideoEncoderAv1Qsv  VideoEncoder = `av1_qsv`
+)
+
+// VAAPI
+const (
+	VideoEncoderH264Vaapi VideoEncoder = `h264_vaapi`
+	VideoEncoderH265Vaapi VideoEncoder = `hevc_vaapi`
+	VideoEncoderVp8Vaapi  VideoEncoder = `vp8_vaapi`
+	VideoEncoderVp9Vaapi  VideoEncoder = `vp9_vaapi`
+	VideoEncoderAv1Vaapi  VideoEncoder = `av1_vaapi`
+)
+
+// AMD GPUS
+const (
+	VideoEncoderH264Amf VideoEncoder = `h264_amf`
+	VideoEncoderH265Amf VideoEncoder = `hevc_amf`
+	VideoEncoderVp8Amf  VideoEncoder = `vp8_amf`
+	VideoEncoderVp9Amf  VideoEncoder = `vp9_amf`
+	VideoEncoderAv1Amf  VideoEncoder = `av1_amf`
+)
+
+type AudioEncoder string
+
+func (a AudioEncoder) Option() string {
+	s := strings.Builder{}
+	s.WriteString(`-c:a `)
+	s.WriteString(string(a))
+	return s.String()
+}
+
+const (
+	AudioEncoderCopy AudioEncoder = `copy`
+	AudioEncoderMp3  AudioEncoder = `mp3`
+	AudioEncoderAac  AudioEncoder = `aac`
+	AudioEncoderFlac AudioEncoder = `flac`
+	AudioEncoderAlac AudioEncoder = `alac`
+)
+
+type None string
+
+func (n None) Option() string {
+	return string(n)
+}
+
+const (
+	VideoNone None = `-vn`
+	AudioNone None = `-an`
+)