< Summary - Jellyfin

Information

Class:	MediaBrowser.Controller.MediaEncoding.EncodingHelper
Assembly:	MediaBrowser.Controller
File(s):	/srv/git/jellyfin/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs

Line coverage

Covered lines:	183
Uncovered lines:	3596
Coverable lines:	3779
Total lines:	7967
Line coverage:	4.8%

Branch coverage

Covered branches:	112
Total branches:	3741
Branch coverage:	2.9%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage delta

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	Line coverage
.ctor(...)	100%	1	1	100%
.cctor()	100%	2	1	0%
GetH264Encoder(...)	100%	2	1	0%
GetH265Encoder(...)	100%	2	1	0%
GetAv1Encoder(...)	100%	2	1	0%
GetH26xOrAv1Encoder(...)	0%	110	10	0%
GetMjpegEncoder(...)	0%	210	14	0%
IsVaapiSupported(...)	0%	20	4	0%
IsVaapiFullSupported()	0%	272	16	0%
IsRkmppFullSupported()	0%	42	6	0%
IsOpenclFullSupported()	0%	42	6	0%
IsCudaFullSupported()	0%	110	10	0%
IsVulkanFullSupported()	0%	110	10	0%
IsVideoToolboxFullSupported()	0%	72	8	0%
IsSwTonemapAvailable(...)	0%	42	6	0%
IsHwTonemapAvailable(...)	0%	420	20	0%
IsVulkanHwTonemapAvailable(...)	0%	42	6	0%
IsIntelVppTonemapAvailable(...)	0%	342	18	0%
IsVideoToolboxTonemapAvailable(...)	0%	210	14	0%
IsDeinterlaceAvailable(...)	0%	20	4	0%
IsVideoStreamHevcRext(...)	0%	342	18	0%
GetVideoEncoder(...)	14.28%	109	14	21.42%
GetUserAgentParam(...)	0%	6	2	0%
GetRefererParam(...)	0%	6	2	0%
GetInputFormat(...)	0%	1482	38	0%
GetDecoderFromCodec(...)	0%	72	8	0%
InferAudioCodec(...)	0%	3422	58	0%
InferVideoCodec(...)	0%	156	12	0%
GetVideoProfileScore(...)	0%	42	6	0%
GetAudioEncoder(...)	0%	420	20	0%
GetRkmppDeviceArgs(...)	0%	6	2	0%
GetVideoToolboxDeviceArgs(...)	0%	6	2	0%
GetCudaDeviceArgs(...)	0%	20	4	0%
GetVulkanDeviceArgs(...)	0%	72	8	0%
GetOpenclDeviceArgs(...)	0%	72	8	0%
GetD3d11vaDeviceArgs(...)	0%	42	6	0%
GetVaapiDeviceArgs(...)	0%	272	16	0%
GetDrmDeviceArgs(...)	0%	20	4	0%
GetQsvDeviceArgs(...)	0%	72	8	0%
GetFilterHwDeviceArgs(...)	0%	6	2	0%
GetGraphicalSubCanvasSize(...)	70%	32	20	68.75%
GetInputVideoHwaccelArgs(...)	2.5%	13097	120	3.41%
GetInputArgument(...)	52.77%	106	36	62.22%
IsH264(...)	0%	20	4	0%
IsH265(...)	0%	20	4	0%
IsAv1(...)	0%	6	2	0%
IsAAC(...)	50%	2	2	100%
IsDoviWithHdr10Bl(...)	0%	72	8	0%
IsDovi(...)	0%	110	10	0%
IsHdr10Plus(...)	0%	72	8	0%
ShouldRemoveDynamicHdrMetadata(...)	0%	600	24	0%
CanEncoderRemoveDynamicHdrMetadata(...)	0%	342	18	0%
IsDoviRemoved(...)	0%	42	6	0%
IsHdr10PlusRemoved(...)	0%	42	6	0%
GetBitStreamArgs(...)	0%	702	26	0%
GetAudioBitStreamArguments(...)	92.85%	14	14	100%
GetCopiedAudioTrimBsf(...)	92.85%	14	14	100%
GetSegmentFileExtension(...)	50%	2	2	66.66%
GetVideoBitrateParam(...)	0%	1806	42	0%
GetEncoderParam(...)	0%	8010	89	0%
NormalizeTranscodingLevel(...)	0%	506	22	0%
GetTextSubtitlesFilter(...)	0%	272	16	0%
GetFramerateParam(...)	0%	156	12	0%
GetHlsVideoKeyFrameArguments(...)	0%	1806	42	0%
GetVideoQualityParam(...)	0%	32580	180	0%
CanStreamCopyVideo(...)	0%	19740	140	0%
CanStreamCopyAudio(...)	0%	1190	34	0%
GetVideoBitrateParamValue(...)	0%	506	22	0%
GetMinBitrate(...)	0%	20	4	0%
GetVideoBitrateScaleFactor(...)	0%	72	8	0%
ScaleBitrate(...)	0%	110	10	0%
GetAudioBitrateParam(...)	100%	2	1	0%
GetAudioBitrateParam(...)	0%	2162	46	0%
GetAudioVbrModeParam(...)	0%	1190	34	0%
GetAudioFilterParam(...)	0%	702	26	0%
GetNumAudioChannelsParam(...)	0%	930	30	0%
EnforceResolutionLimit(...)	0%	20	4	0%
GetFastSeekCommandLineParameter(...)	10%	23	10	50%
GetMapArgs(...)	50%	84	36	66.66%
GetNegativeMapArgsByFilters(...)	0%	20	4	0%
GetMediaStream(...)	0%	156	12	0%
GetFixedOutputSize(...)	0%	272	16	0%
IsScaleRatioSupported(...)	0%	506	22	0%
GetHwScaleFilter(...)	0%	600	24	0%
GetGraphicalSubPreProcessFilters(...)	0%	342	18	0%
GetAlphaSrcFilter(...)	0%	42	6	0%
GetSwScaleFilter(...)	0%	702	26	0%
GetFixedSwScaleFilter(...)	0%	132	11	0%
GetSwDeinterlaceFilter(...)	0%	42	6	0%
GetHwDeinterlaceFilter(...)	0%	1332	36	0%
GetHwTonemapFilter(...)	0%	1332	36	0%
GetLibplaceboFilter(...)	0%	506	22	0%
GetVideoTransposeDirection(...)	0%	156	12	0%
GetSwVidFilterChain(...)	0%	2162	46	0%
GetNvidiaVidFilterChain(...)	0%	110	10	0%
GetNvidiaVidFiltersPrefered(...)	0%	7140	84	0%
GetAmdVidFilterChain(...)	0%	210	14	0%
GetAmdDx11VidFiltersPrefered(...)	0%	7140	84	0%
GetIntelVidFilterChain(...)	0%	506	22	0%
GetIntelQsvDx11VidFiltersPrefered(...)	0%	19740	140	0%
GetIntelQsvVaapiVidFiltersPrefered(...)	0%	16512	128	0%
GetVaapiVidFilterChain(...)	0%	1190	34	0%
GetIntelVaapiFullVidFiltersPrefered(...)	0%	11772	108	0%
GetAmdVaapiFullVidFiltersPrefered(...)	0%	9312	96	0%
GetVaapiLimitedVidFiltersPrefered(...)	0%	7482	86	0%
GetAppleVidFilterChain(...)	0%	156	12	0%
GetAppleVidFiltersPreferred(...)	0%	4970	70	0%
GetRkmppVidFilterChain(...)	0%	272	16	0%
GetRkmppVidFiltersPrefered(...)	0%	15006	122	0%
GetVideoProcessingFilterParam(...)	0%	3192	56	0%
GetOverwriteColorPropertiesParam(...)	0%	20	4	0%
GetInputHdrParam(...)	0%	6	2	0%
GetOutputSdrParam(...)	0%	20	4	0%
GetVideoColorBitDepth(...)	0%	600	24	0%
GetHardwareVideoDecoder(...)	17.74%	1684	62	25%
GetHwDecoderName(...)	0%	1190	34	0%
GetHwaccelType(...)	0%	15006	122	0%
GetQsvHwVidDecoder(...)	0%	3192	56	0%
GetNvdecVidDecoder(...)	0%	2162	46	0%
GetAmfVidDecoder(...)	0%	1056	32	0%
GetVaapiVidDecoder(...)	0%	2756	52	0%
GetVideotoolboxVidDecoder(...)	0%	2352	48	0%
GetRkmppVidDecoder(...)	0%	2756	52	0%
GetNumberOfThreads(...)	0%	42	6	0%
TryStreamCopy(...)	0%	600	24	0%
GetFfmpegAnalyzeDurationArg(...)	50%	7	6	71.42%
GetFfmpegProbesizeArg()	50%	2	2	75%
GetInputModifier(...)	0%	3660	60	0%
AttachMediaSourceInfo(...)	0%	1806	42	0%
ShiftAudioCodecsIfNeeded(...)	0%	110	10	0%
ShiftVideoCodecsIfNeeded(...)	0%	110	10	0%
NormalizeSubtitleEmbed(...)	0%	42	6	0%
GetSubtitleEmbedArguments(...)	0%	72	8	0%
GetProgressiveVideoFullCommandLine(...)	0%	20	4	0%
GetOutputFFlags(...)	0%	20	4	0%
GetProgressiveVideoArguments(...)	0%	1482	38	0%
GetProgressiveVideoAudioArguments(...)	0%	600	24	0%
GetProgressiveAudioFullCommandLine(...)	0%	930	30	0%
FindIndex(...)	66.66%	6	6	88.88%
IsCopyCodec(...)	100%	1	1	100%
ShouldEncodeSubtitle(...)	75%	4	4	100%
NeedsExternalSubtitleMuxing(...)	62.5%	8	8	100%
GetVideoSyncOption(...)	0%	132	11	0%

File(s)

/srv/git/jellyfin/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs

#	Line	Line coverage
	`1`	`#nullable disable`
	`2`
	`3`	`#pragma warning disable CS1591`
	`4`	`// We need lowercase normalized string for ffmpeg`
	`5`	`#pragma warning disable CA1308`
	`6`
	`7`	`using System;`
	`8`	`using System.Collections.Generic;`
	`9`	`using System.Globalization;`
	`10`	`using System.IO;`
	`11`	`using System.Linq;`
	`12`	`using System.Runtime.InteropServices;`
	`13`	`using System.Text;`
	`14`	`using System.Text.RegularExpressions;`
	`15`	`using System.Threading;`
	`16`	`using Jellyfin.Data;`
	`17`	`using Jellyfin.Data.Enums;`
	`18`	`using Jellyfin.Database.Implementations.Enums;`
	`19`	`using Jellyfin.Extensions;`
	`20`	`using MediaBrowser.Common.Configuration;`
	`21`	`using MediaBrowser.Controller.Extensions;`
	`22`	`using MediaBrowser.Controller.IO;`
	`23`	`using MediaBrowser.Model.Configuration;`
	`24`	`using MediaBrowser.Model.Dlna;`
	`25`	`using MediaBrowser.Model.Dto;`
	`26`	`using MediaBrowser.Model.Entities;`
	`27`	`using MediaBrowser.Model.MediaInfo;`
	`28`	`using Microsoft.Extensions.Configuration;`
	`29`	`using IConfigurationManager = MediaBrowser.Common.Configuration.IConfigurationManager;`
	`30`
	`31`	`namespace MediaBrowser.Controller.MediaEncoding`
	`32`	`{`
	`33`	`public partial class EncodingHelper`
	`34`	`{`
	`35`	`/// <summary>`
	`36`	`/// The codec validation regex string.`
	`37`	`/// This regular expression matches strings that consist of alphanumeric characters, hyphens,`
	`38`	`/// periods, underscores, commas, and vertical bars, with a length between 0 and 40 characters.`
	`39`	`/// This should matches all common valid codecs.`
	`40`	`/// </summary>`
	`41`	`public const string ContainerValidationRegexStr = @"^[a-zA-Z0-9\-\._,\|]{0,40}$";`
	`42`
	`43`	`/// <summary>`
	`44`	`/// The level validation regex string.`
	`45`	`/// This regular expression matches strings representing a double.`
	`46`	`/// </summary>`
	`47`	`public const string LevelValidationRegexStr = @"-?[0-9]+(?:\.[0-9]+)?";`
	`48`
	`49`	`private const string _defaultMjpegEncoder = "mjpeg";`
	`50`
	`51`	`private const string QsvAlias = "qs";`
	`52`	`private const string VaapiAlias = "va";`
	`53`	`private const string D3d11vaAlias = "dx11";`
	`54`	`private const string VideotoolboxAlias = "vt";`
	`55`	`private const string RkmppAlias = "rk";`
	`56`	`private const string OpenclAlias = "ocl";`
	`57`	`private const string CudaAlias = "cu";`
	`58`	`private const string DrmAlias = "dr";`
	`59`	`private const string VulkanAlias = "vk";`
	`60`	`private readonly IApplicationPaths _appPaths;`
	`61`	`private readonly IMediaEncoder _mediaEncoder;`
	`62`	`private readonly ISubtitleEncoder _subtitleEncoder;`
	`63`	`private readonly IConfiguration _config;`
	`64`	`private readonly IConfigurationManager _configurationManager;`
	`65`	`private readonly IPathManager _pathManager;`
	`66`
	`67`	`// i915 hang was fixed by linux 6.2 (3f882f2)`
44	`68`	`private readonly Version _minKerneli915Hang = new Version(5, 18);`
44	`69`	`private readonly Version _maxKerneli915Hang = new Version(6, 1, 3);`
44	`70`	`private readonly Version _minFixedKernel60i915Hang = new Version(6, 0, 18);`
44	`71`	`private readonly Version _minKernelVersionAmdVkFmtModifier = new Version(5, 15);`
	`72`
44	`73`	`private readonly Version _minFFmpegImplicitHwaccel = new Version(6, 0);`
44	`74`	`private readonly Version _minFFmpegHwaUnsafeOutput = new Version(6, 0);`
44	`75`	`private readonly Version _minFFmpegOclCuTonemapMode = new Version(5, 1, 3);`
44	`76`	`private readonly Version _minFFmpegSvtAv1Params = new Version(5, 1);`
44	`77`	`private readonly Version _minFFmpegVaapiH26xEncA53CcSei = new Version(6, 0);`
44	`78`	`private readonly Version _minFFmpegReadrateOption = new Version(5, 0);`
44	`79`	`private readonly Version _minFFmpegWorkingVtHwSurface = new Version(7, 0, 1);`
44	`80`	`private readonly Version _minFFmpegDisplayRotationOption = new Version(6, 0);`
44	`81`	`private readonly Version _minFFmpegAdvancedTonemapMode = new Version(7, 0, 1);`
44	`82`	`private readonly Version _minFFmpegAlteredVaVkInterop = new Version(7, 0, 1);`
44	`83`	`private readonly Version _minFFmpegQsvVppTonemapOption = new Version(7, 0, 1);`
44	`84`	`private readonly Version _minFFmpegQsvVppOutRangeOption = new Version(7, 0, 1);`
44	`85`	`private readonly Version _minFFmpegVaapiDeviceVendorId = new Version(7, 0, 1);`
44	`86`	`private readonly Version _minFFmpegQsvVppScaleModeOption = new Version(6, 0);`
44	`87`	`private readonly Version _minFFmpegRkmppHevcDecDoviRpu = new Version(7, 1, 1);`
44	`88`	`private readonly Version _minFFmpegReadrateCatchupOption = new Version(8, 0);`
44	`89`	`private readonly Version _minFFmpegNoiseBsfDrop = new Version(5, 0);`
	`90`
0	`91`	`private static readonly string[] _videoProfilesH264 =`
0	`92`	`[`
0	`93`	`"ConstrainedBaseline",`
0	`94`	`"Baseline",`
0	`95`	`"Extended",`
0	`96`	`"Main",`
0	`97`	`"High",`
0	`98`	`"ProgressiveHigh",`
0	`99`	`"ConstrainedHigh",`
0	`100`	`"High10"`
0	`101`	`];`
	`102`
0	`103`	`private static readonly string[] _videoProfilesH265 =`
0	`104`	`[`
0	`105`	`"Main",`
0	`106`	`"Main10"`
0	`107`	`];`
	`108`
0	`109`	`private static readonly string[] _videoProfilesAv1 =`
0	`110`	`[`
0	`111`	`"Main",`
0	`112`	`"High",`
0	`113`	`"Professional",`
0	`114`	`];`
	`115`
0	`116`	`private static readonly HashSet<string> _mp4ContainerNames = new(StringComparer.OrdinalIgnoreCase)`
0	`117`	`{`
0	`118`	`"mp4",`
0	`119`	`"m4a",`
0	`120`	`"m4p",`
0	`121`	`"m4b",`
0	`122`	`"m4r",`
0	`123`	`"m4v",`
0	`124`	`};`
	`125`
0	`126`	`private static readonly TonemappingMode[] _legacyTonemapModes = [TonemappingMode.max, TonemappingMode.rgb];`
0	`127`	`private static readonly TonemappingMode[] _advancedTonemapModes = [TonemappingMode.lum, TonemappingMode.itp];`
	`128`
	`129`	`// Set max transcoding channels for encoders that can't handle more than a set amount of channels`
	`130`	`// AAC, FLAC, ALAC, libopus, libvorbis encoders all support at least 8 channels`
0	`131`	`private static readonly Dictionary<string, int> _audioTranscodeChannelLookup = new(StringComparer.OrdinalIgnoreC`
0	`132`	`{`
0	`133`	`{ "libmp3lame", 2 },`
0	`134`	`{ "libfdk_aac", 6 },`
0	`135`	`{ "ac3", 6 },`
0	`136`	`{ "eac3", 6 },`
0	`137`	`{ "dca", 6 },`
0	`138`	`{ "mlp", 6 },`
0	`139`	`{ "truehd", 6 },`
0	`140`	`};`
	`141`
0	`142`	`private static readonly Dictionary<HardwareAccelerationType, string> _mjpegCodecMap = new()`
0	`143`	`{`
0	`144`	`{ HardwareAccelerationType.vaapi, _defaultMjpegEncoder + "_vaapi" },`
0	`145`	`{ HardwareAccelerationType.qsv, _defaultMjpegEncoder + "_qsv" },`
0	`146`	`{ HardwareAccelerationType.videotoolbox, _defaultMjpegEncoder + "_videotoolbox" },`
0	`147`	`{ HardwareAccelerationType.rkmpp, _defaultMjpegEncoder + "_rkmpp" }`
0	`148`	`};`
	`149`
0	`150`	`public static readonly string[] LosslessAudioCodecs =`
0	`151`	`[`
0	`152`	`"alac",`
0	`153`	`"ape",`
0	`154`	`"flac",`
0	`155`	`"mlp",`
0	`156`	`"truehd",`
0	`157`	`"wavpack"`
0	`158`	`];`
	`159`
	`160`	`public EncodingHelper(`
	`161`	`IApplicationPaths appPaths,`
	`162`	`IMediaEncoder mediaEncoder,`
	`163`	`ISubtitleEncoder subtitleEncoder,`
	`164`	`IConfiguration config,`
	`165`	`IConfigurationManager configurationManager,`
	`166`	`IPathManager pathManager)`
	`167`	`{`
44	`168`	`_appPaths = appPaths;`
44	`169`	`_mediaEncoder = mediaEncoder;`
44	`170`	`_subtitleEncoder = subtitleEncoder;`
44	`171`	`_config = config;`
44	`172`	`_configurationManager = configurationManager;`
44	`173`	`_pathManager = pathManager;`
44	`174`	`}`
	`175`
	`176`	`private enum DynamicHdrMetadataRemovalPlan`
	`177`	`{`
	`178`	`None,`
	`179`	`RemoveDovi,`
	`180`	`RemoveHdr10Plus,`
	`181`	`}`
	`182`
	`183`	`/// <summary>`
	`184`	`/// The codec validation regex.`
	`185`	`/// This regular expression matches strings that consist of alphanumeric characters, hyphens,`
	`186`	`/// periods, underscores, commas, and vertical bars, with a length between 0 and 40 characters.`
	`187`	`/// This should matches all common valid codecs.`
	`188`	`/// </summary>`
	`189`	`[GeneratedRegex(ContainerValidationRegexStr)]`
	`190`	`public static partial Regex ContainerValidationRegex();`
	`191`
	`192`	`/// <summary>`
	`193`	`/// The level validation regex string.`
	`194`	`/// This regular expression matches strings representing a double.`
	`195`	`/// </summary>`
	`196`	`[GeneratedRegex(LevelValidationRegexStr)]`
	`197`	`public static partial Regex LevelValidationRegex();`
	`198`
	`199`	`[GeneratedRegex(@"\s+")]`
	`200`	`private static partial Regex WhiteSpaceRegex();`
	`201`
	`202`	`public string GetH264Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)`
0	`203`	`=> GetH26xOrAv1Encoder("libx264", "h264", state, encodingOptions);`
	`204`
	`205`	`public string GetH265Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)`
0	`206`	`=> GetH26xOrAv1Encoder("libx265", "hevc", state, encodingOptions);`
	`207`
	`208`	`public string GetAv1Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)`
0	`209`	`=> GetH26xOrAv1Encoder("libsvtav1", "av1", state, encodingOptions);`
	`210`
	`211`	`private string GetH26xOrAv1Encoder(string defaultEncoder, string hwEncoder, EncodingJobInfo state, EncodingOptio`
	`212`	`{`
	`213`	`// Only use alternative encoders for video files.`
	`214`	`// When using concat with folder rips, if the mfx session fails to initialize, ffmpeg will be stuck retrying`
	`215`	`// Since transcoding of folder rips is experimental anyway, it's not worth adding additional variables such`
0	`216`	`if (state.VideoType == VideoType.VideoFile)`
	`217`	`{`
0	`218`	`var hwType = encodingOptions.HardwareAccelerationType;`
	`219`
0	`220`	`var codecMap = new Dictionary<HardwareAccelerationType, string>()`
0	`221`	`{`
0	`222`	`{ HardwareAccelerationType.amf, hwEncoder + "_amf" },`
0	`223`	`{ HardwareAccelerationType.nvenc, hwEncoder + "_nvenc" },`
0	`224`	`{ HardwareAccelerationType.qsv, hwEncoder + "_qsv" },`
0	`225`	`{ HardwareAccelerationType.vaapi, hwEncoder + "_vaapi" },`
0	`226`	`{ HardwareAccelerationType.videotoolbox, hwEncoder + "_videotoolbox" },`
0	`227`	`{ HardwareAccelerationType.v4l2m2m, hwEncoder + "_v4l2m2m" },`
0	`228`	`{ HardwareAccelerationType.rkmpp, hwEncoder + "_rkmpp" },`
0	`229`	`};`
	`230`
0	`231`	`if (hwType != HardwareAccelerationType.none`
0	`232`	`&& encodingOptions.EnableHardwareEncoding`
0	`233`	`&& codecMap.TryGetValue(hwType, out var preferredEncoder)`
0	`234`	`&& _mediaEncoder.SupportsEncoder(preferredEncoder))`
	`235`	`{`
0	`236`	`return preferredEncoder;`
	`237`	`}`
	`238`	`}`
	`239`
0	`240`	`return defaultEncoder;`
	`241`	`}`
	`242`
	`243`	`private string GetMjpegEncoder(EncodingJobInfo state, EncodingOptions encodingOptions)`
	`244`	`{`
0	`245`	`if (state.VideoType == VideoType.VideoFile)`
	`246`	`{`
0	`247`	`var hwType = encodingOptions.HardwareAccelerationType;`
	`248`
	`249`	`// Only enable VA-API MJPEG encoder on Intel iHD driver.`
	`250`	`// Legacy platforms supported ONLY by i965 do not support MJPEG encoder.`
0	`251`	`if (hwType == HardwareAccelerationType.vaapi`
0	`252`	`&& !_mediaEncoder.IsVaapiDeviceInteliHD)`
	`253`	`{`
0	`254`	`return _defaultMjpegEncoder;`
	`255`	`}`
	`256`
0	`257`	`if (hwType != HardwareAccelerationType.none`
0	`258`	`&& encodingOptions.EnableHardwareEncoding`
0	`259`	`&& _mjpegCodecMap.TryGetValue(hwType, out var preferredEncoder)`
0	`260`	`&& _mediaEncoder.SupportsEncoder(preferredEncoder))`
	`261`	`{`
0	`262`	`return preferredEncoder;`
	`263`	`}`
	`264`	`}`
	`265`
0	`266`	`return _defaultMjpegEncoder;`
	`267`	`}`
	`268`
	`269`	`private bool IsVaapiSupported(EncodingJobInfo state)`
	`270`	`{`
	`271`	`// vaapi will throw an error with this input`
	`272`	`// [vaapi @ 0x7faed8000960] No VAAPI support for codec mpeg4 profile -99.`
0	`273`	`if (string.Equals(state.VideoStream?.Codec, "mpeg4", StringComparison.OrdinalIgnoreCase))`
	`274`	`{`
0	`275`	`return false;`
	`276`	`}`
	`277`
0	`278`	`return _mediaEncoder.SupportsHwaccel("vaapi");`
	`279`	`}`
	`280`
	`281`	`private bool IsVaapiFullSupported()`
	`282`	`{`
0	`283`	`return _mediaEncoder.SupportsHwaccel("drm")`
0	`284`	`&& _mediaEncoder.SupportsHwaccel("vaapi")`
0	`285`	`&& _mediaEncoder.SupportsFilter("scale_vaapi")`
0	`286`	`&& _mediaEncoder.SupportsFilter("deinterlace_vaapi")`
0	`287`	`&& _mediaEncoder.SupportsFilter("tonemap_vaapi")`
0	`288`	`&& _mediaEncoder.SupportsFilter("procamp_vaapi")`
0	`289`	`&& _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayVaapiFrameSync)`
0	`290`	`&& _mediaEncoder.SupportsFilter("transpose_vaapi")`
0	`291`	`&& _mediaEncoder.SupportsFilter("hwupload_vaapi");`
	`292`	`}`
	`293`
	`294`	`private bool IsRkmppFullSupported()`
	`295`	`{`
0	`296`	`return _mediaEncoder.SupportsHwaccel("rkmpp")`
0	`297`	`&& _mediaEncoder.SupportsFilter("scale_rkrga")`
0	`298`	`&& _mediaEncoder.SupportsFilter("vpp_rkrga")`
0	`299`	`&& _mediaEncoder.SupportsFilter("overlay_rkrga");`
	`300`	`}`
	`301`
	`302`	`private bool IsOpenclFullSupported()`
	`303`	`{`
0	`304`	`return _mediaEncoder.SupportsHwaccel("opencl")`
0	`305`	`&& _mediaEncoder.SupportsFilter("scale_opencl")`
0	`306`	`&& _mediaEncoder.SupportsFilterWithOption(FilterOptionType.TonemapOpenclBt2390)`
0	`307`	`&& _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayOpenclFrameSync);`
	`308`
	`309`	`// Let transpose_opencl optional for the time being.`
	`310`	`}`
	`311`
	`312`	`private bool IsCudaFullSupported()`
	`313`	`{`
0	`314`	`return _mediaEncoder.SupportsHwaccel("cuda")`
0	`315`	`&& _mediaEncoder.SupportsFilterWithOption(FilterOptionType.ScaleCudaFormat)`
0	`316`	`&& _mediaEncoder.SupportsFilter("yadif_cuda")`
0	`317`	`&& _mediaEncoder.SupportsFilterWithOption(FilterOptionType.TonemapCudaName)`
0	`318`	`&& _mediaEncoder.SupportsFilter("overlay_cuda")`
0	`319`	`&& _mediaEncoder.SupportsFilter("hwupload_cuda");`
	`320`
	`321`	`// Let transpose_cuda optional for the time being.`
	`322`	`}`
	`323`
	`324`	`private bool IsVulkanFullSupported()`
	`325`	`{`
0	`326`	`return _mediaEncoder.SupportsHwaccel("vulkan")`
0	`327`	`&& _mediaEncoder.SupportsFilter("libplacebo")`
0	`328`	`&& _mediaEncoder.SupportsFilter("scale_vulkan")`
0	`329`	`&& _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayVulkanFrameSync)`
0	`330`	`&& _mediaEncoder.SupportsFilter("transpose_vulkan")`
0	`331`	`&& _mediaEncoder.SupportsFilter("flip_vulkan");`
	`332`	`}`
	`333`
	`334`	`private bool IsVideoToolboxFullSupported()`
	`335`	`{`
0	`336`	`return _mediaEncoder.SupportsHwaccel("videotoolbox")`
0	`337`	`&& _mediaEncoder.SupportsFilter("yadif_videotoolbox")`
0	`338`	`&& _mediaEncoder.SupportsFilter("overlay_videotoolbox")`
0	`339`	`&& _mediaEncoder.SupportsFilter("tonemap_videotoolbox")`
0	`340`	`&& _mediaEncoder.SupportsFilter("scale_vt");`
	`341`
	`342`	`// Let transpose_vt optional for the time being.`
	`343`	`}`
	`344`
	`345`	`private bool IsSwTonemapAvailable(EncodingJobInfo state, EncodingOptions options)`
	`346`	`{`
0	`347`	`if (state.VideoStream is null`
0	`348`	`\|\| GetVideoColorBitDepth(state) < 10`
0	`349`	`\|\| !_mediaEncoder.SupportsFilter("tonemapx"))`
	`350`	`{`
0	`351`	`return false;`
	`352`	`}`
	`353`
0	`354`	`return state.VideoStream.VideoRange == VideoRange.HDR;`
	`355`	`}`
	`356`
	`357`	`private bool IsHwTonemapAvailable(EncodingJobInfo state, EncodingOptions options)`
	`358`	`{`
0	`359`	`if (state.VideoStream is null`
0	`360`	`\|\| !options.EnableTonemapping`
0	`361`	`\|\| GetVideoColorBitDepth(state) < 10)`
	`362`	`{`
0	`363`	`return false;`
	`364`	`}`
	`365`
0	`366`	`if (state.VideoStream.VideoRange == VideoRange.HDR`
0	`367`	`&& state.VideoStream.VideoRangeType == VideoRangeType.DOVI)`
	`368`	`{`
	`369`	`// Only native SW decoder, HW accelerator and hevc_rkmpp decoder can parse dovi rpu.`
0	`370`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
	`371`
0	`372`	`var isRkmppDecoder = vidDecoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);`
0	`373`	`if (isRkmppDecoder`
0	`374`	`&& _mediaEncoder.EncoderVersion >= _minFFmpegRkmppHevcDecDoviRpu`
0	`375`	`&& string.Equals(state.VideoStream?.Codec, "hevc", StringComparison.OrdinalIgnoreCase))`
	`376`	`{`
0	`377`	`return true;`
	`378`	`}`
	`379`
0	`380`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`381`	`var isNvdecDecoder = vidDecoder.Contains("cuda", StringComparison.OrdinalIgnoreCase);`
0	`382`	`var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`383`	`var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);`
0	`384`	`var isVideoToolBoxDecoder = vidDecoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);`
0	`385`	`return isSwDecoder \|\| isNvdecDecoder \|\| isVaapiDecoder \|\| isD3d11vaDecoder \|\| isVideoToolBoxDecoder;`
	`386`	`}`
	`387`
	`388`	`// GPU tonemapping supports all HDR RangeTypes`
0	`389`	`return state.VideoStream.VideoRange == VideoRange.HDR;`
	`390`	`}`
	`391`
	`392`	`private bool IsVulkanHwTonemapAvailable(EncodingJobInfo state, EncodingOptions options)`
	`393`	`{`
0	`394`	`if (state.VideoStream is null)`
	`395`	`{`
0	`396`	`return false;`
	`397`	`}`
	`398`
	`399`	`// libplacebo has partial Dolby Vision to SDR tonemapping support.`
0	`400`	`return options.EnableTonemapping`
0	`401`	`&& state.VideoStream.VideoRange == VideoRange.HDR`
0	`402`	`&& GetVideoColorBitDepth(state) == 10;`
	`403`	`}`
	`404`
	`405`	`private bool IsIntelVppTonemapAvailable(EncodingJobInfo state, EncodingOptions options)`
	`406`	`{`
0	`407`	`if (state.VideoStream is null`
0	`408`	`\|\| !options.EnableVppTonemapping`
0	`409`	`\|\| GetVideoColorBitDepth(state) < 10)`
	`410`	`{`
0	`411`	`return false;`
	`412`	`}`
	`413`
	`414`	`// prefer 'tonemap_vaapi' over 'vpp_qsv' on Linux for supporting Gen9/KBLx.`
	`415`	`// 'vpp_qsv' requires VPL, which is only supported on Gen12/TGLx and newer.`
0	`416`	`if (OperatingSystem.IsWindows()`
0	`417`	`&& options.HardwareAccelerationType == HardwareAccelerationType.qsv`
0	`418`	`&& _mediaEncoder.EncoderVersion < _minFFmpegQsvVppTonemapOption)`
	`419`	`{`
0	`420`	`return false;`
	`421`	`}`
	`422`
0	`423`	`return state.VideoStream.VideoRange == VideoRange.HDR`
0	`424`	`&& (state.VideoStream.VideoRangeType == VideoRangeType.HDR10`
0	`425`	`\|\| IsHdr10Plus(state.VideoStream)`
0	`426`	`\|\| IsDoviWithHdr10Bl(state.VideoStream));`
	`427`	`}`
	`428`
	`429`	`private bool IsVideoToolboxTonemapAvailable(EncodingJobInfo state, EncodingOptions options)`
	`430`	`{`
0	`431`	`if (state.VideoStream is null`
0	`432`	`\|\| !options.EnableVideoToolboxTonemapping`
0	`433`	`\|\| GetVideoColorBitDepth(state) < 10)`
	`434`	`{`
0	`435`	`return false;`
	`436`	`}`
	`437`
	`438`	`// Certain DV profile 5 video works in Safari with direct playing, but the VideoToolBox does not produce cor`
	`439`	`// All other HDR formats working.`
0	`440`	`return state.VideoStream.VideoRange == VideoRange.HDR`
0	`441`	`&& (state.VideoStream.VideoRangeType == VideoRangeType.HDR10`
0	`442`	`\|\| IsHdr10Plus(state.VideoStream)`
0	`443`	`\|\| IsDoviWithHdr10Bl(state.VideoStream)`
0	`444`	`\|\| state.VideoStream.VideoRangeType == VideoRangeType.HLG);`
	`445`	`}`
	`446`
	`447`	`private static bool IsDeinterlaceAvailable(EncodingJobInfo state)`
	`448`	`{`
0	`449`	`var doDeintH264 = state.DeInterlace("h264", true) \|\| state.DeInterlace("avc", true);`
0	`450`	`var doDeintHevc = state.DeInterlace("h265", true) \|\| state.DeInterlace("hevc", true);`
0	`451`	`return doDeintH264 \|\| doDeintHevc;`
	`452`	`}`
	`453`
	`454`	`private bool IsVideoStreamHevcRext(EncodingJobInfo state)`
	`455`	`{`
0	`456`	`var videoStream = state.VideoStream;`
0	`457`	`if (videoStream is null)`
	`458`	`{`
0	`459`	`return false;`
	`460`	`}`
	`461`
0	`462`	`return string.Equals(videoStream.Codec, "hevc", StringComparison.OrdinalIgnoreCase)`
0	`463`	`&& (string.Equals(videoStream.Profile, "Rext", StringComparison.OrdinalIgnoreCase)`
0	`464`	`\|\| string.Equals(videoStream.PixelFormat, "yuv420p12le", StringComparison.OrdinalIgnoreCase)`
0	`465`	`\|\| string.Equals(videoStream.PixelFormat, "yuv422p", StringComparison.OrdinalIgnoreCase)`
0	`466`	`\|\| string.Equals(videoStream.PixelFormat, "yuv422p10le", StringComparison.OrdinalIgnoreCase)`
0	`467`	`\|\| string.Equals(videoStream.PixelFormat, "yuv422p12le", StringComparison.OrdinalIgnoreCase)`
0	`468`	`\|\| string.Equals(videoStream.PixelFormat, "yuv444p", StringComparison.OrdinalIgnoreCase)`
0	`469`	`\|\| string.Equals(videoStream.PixelFormat, "yuv444p10le", StringComparison.OrdinalIgnoreCase)`
0	`470`	`\|\| string.Equals(videoStream.PixelFormat, "yuv444p12le", StringComparison.OrdinalIgnoreCase));`
	`471`	`}`
	`472`
	`473`	`/// <summary>`
	`474`	`/// Gets the name of the output video codec.`
	`475`	`/// </summary>`
	`476`	`/// <param name="state">Encoding state.</param>`
	`477`	`/// <param name="encodingOptions">Encoding options.</param>`
	`478`	`/// <returns>Encoder string.</returns>`
	`479`	`public string GetVideoEncoder(EncodingJobInfo state, EncodingOptions encodingOptions)`
	`480`	`{`
4	`481`	`var codec = state.OutputVideoCodec;`
	`482`
4	`483`	`if (!string.IsNullOrEmpty(codec))`
	`484`	`{`
0	`485`	`if (string.Equals(codec, "av1", StringComparison.OrdinalIgnoreCase))`
	`486`	`{`
0	`487`	`return GetAv1Encoder(state, encodingOptions);`
	`488`	`}`
	`489`
0	`490`	`if (string.Equals(codec, "h265", StringComparison.OrdinalIgnoreCase)`
0	`491`	`\|\| string.Equals(codec, "hevc", StringComparison.OrdinalIgnoreCase))`
	`492`	`{`
0	`493`	`return GetH265Encoder(state, encodingOptions);`
	`494`	`}`
	`495`
0	`496`	`if (string.Equals(codec, "h264", StringComparison.OrdinalIgnoreCase))`
	`497`	`{`
0	`498`	`return GetH264Encoder(state, encodingOptions);`
	`499`	`}`
	`500`
0	`501`	`if (string.Equals(codec, "mjpeg", StringComparison.OrdinalIgnoreCase))`
	`502`	`{`
0	`503`	`return GetMjpegEncoder(state, encodingOptions);`
	`504`	`}`
	`505`
0	`506`	`if (ContainerValidationRegex().IsMatch(codec))`
	`507`	`{`
0	`508`	`return codec.ToLowerInvariant();`
	`509`	`}`
	`510`	`}`
	`511`
4	`512`	`return "copy";`
	`513`	`}`
	`514`
	`515`	`/// <summary>`
	`516`	`/// Gets the user agent param.`
	`517`	`/// </summary>`
	`518`	`/// <param name="state">The state.</param>`
	`519`	`/// <returns>System.String.</returns>`
	`520`	`public string GetUserAgentParam(EncodingJobInfo state)`
	`521`	`{`
0	`522`	`if (state.RemoteHttpHeaders.TryGetValue("User-Agent", out string useragent))`
	`523`	`{`
0	`524`	`return "-user_agent \"" + useragent + "\"";`
	`525`	`}`
	`526`
0	`527`	`return string.Empty;`
	`528`	`}`
	`529`
	`530`	`/// <summary>`
	`531`	`/// Gets the referer param.`
	`532`	`/// </summary>`
	`533`	`/// <param name="state">The state.</param>`
	`534`	`/// <returns>System.String.</returns>`
	`535`	`public string GetRefererParam(EncodingJobInfo state)`
	`536`	`{`
0	`537`	`if (state.RemoteHttpHeaders.TryGetValue("Referer", out string referer))`
	`538`	`{`
0	`539`	`return "-referer \"" + referer + "\"";`
	`540`	`}`
	`541`
0	`542`	`return string.Empty;`
	`543`	`}`
	`544`
	`545`	`public static string GetInputFormat(string container)`
	`546`	`{`
0	`547`	`if (string.IsNullOrEmpty(container) \|\| !ContainerValidationRegex().IsMatch(container))`
	`548`	`{`
0	`549`	`return null;`
	`550`	`}`
	`551`
0	`552`	`container = container.Replace("mkv", "matroska", StringComparison.OrdinalIgnoreCase);`
	`553`
0	`554`	`if (string.Equals(container, "ts", StringComparison.OrdinalIgnoreCase))`
	`555`	`{`
0	`556`	`return "mpegts";`
	`557`	`}`
	`558`
	`559`	`// For these need to find out the ffmpeg names`
0	`560`	`if (string.Equals(container, "m2ts", StringComparison.OrdinalIgnoreCase))`
	`561`	`{`
0	`562`	`return null;`
	`563`	`}`
	`564`
0	`565`	`if (string.Equals(container, "wmv", StringComparison.OrdinalIgnoreCase))`
	`566`	`{`
0	`567`	`return null;`
	`568`	`}`
	`569`
0	`570`	`if (string.Equals(container, "mts", StringComparison.OrdinalIgnoreCase))`
	`571`	`{`
0	`572`	`return null;`
	`573`	`}`
	`574`
0	`575`	`if (string.Equals(container, "vob", StringComparison.OrdinalIgnoreCase))`
	`576`	`{`
0	`577`	`return null;`
	`578`	`}`
	`579`
0	`580`	`if (string.Equals(container, "mpg", StringComparison.OrdinalIgnoreCase))`
	`581`	`{`
0	`582`	`return null;`
	`583`	`}`
	`584`
0	`585`	`if (string.Equals(container, "mpeg", StringComparison.OrdinalIgnoreCase))`
	`586`	`{`
0	`587`	`return null;`
	`588`	`}`
	`589`
0	`590`	`if (string.Equals(container, "rec", StringComparison.OrdinalIgnoreCase))`
	`591`	`{`
0	`592`	`return null;`
	`593`	`}`
	`594`
0	`595`	`if (string.Equals(container, "dvr-ms", StringComparison.OrdinalIgnoreCase))`
	`596`	`{`
0	`597`	`return null;`
	`598`	`}`
	`599`
0	`600`	`if (string.Equals(container, "ogm", StringComparison.OrdinalIgnoreCase))`
	`601`	`{`
0	`602`	`return null;`
	`603`	`}`
	`604`
0	`605`	`if (string.Equals(container, "divx", StringComparison.OrdinalIgnoreCase))`
	`606`	`{`
0	`607`	`return null;`
	`608`	`}`
	`609`
0	`610`	`if (string.Equals(container, "tp", StringComparison.OrdinalIgnoreCase))`
	`611`	`{`
0	`612`	`return null;`
	`613`	`}`
	`614`
0	`615`	`if (string.Equals(container, "rmvb", StringComparison.OrdinalIgnoreCase))`
	`616`	`{`
0	`617`	`return null;`
	`618`	`}`
	`619`
0	`620`	`if (string.Equals(container, "rtp", StringComparison.OrdinalIgnoreCase))`
	`621`	`{`
0	`622`	`return null;`
	`623`	`}`
	`624`
	`625`	`// Seeing reported failures here, not sure yet if this is related to specifying input format`
0	`626`	`if (string.Equals(container, "m4v", StringComparison.OrdinalIgnoreCase))`
	`627`	`{`
0	`628`	`return null;`
	`629`	`}`
	`630`
	`631`	`// obviously don't do this for strm files`
0	`632`	`if (string.Equals(container, "strm", StringComparison.OrdinalIgnoreCase))`
	`633`	`{`
0	`634`	`return null;`
	`635`	`}`
	`636`
	`637`	`// ISO files don't have an ffmpeg format`
0	`638`	`if (string.Equals(container, "iso", StringComparison.OrdinalIgnoreCase))`
	`639`	`{`
0	`640`	`return null;`
	`641`	`}`
	`642`
0	`643`	`return container;`
	`644`	`}`
	`645`
	`646`	`/// <summary>`
	`647`	`/// Gets decoder from a codec.`
	`648`	`/// </summary>`
	`649`	`/// <param name="codec">Codec to use.</param>`
	`650`	`/// <returns>Decoder string.</returns>`
	`651`	`public string GetDecoderFromCodec(string codec)`
	`652`	`{`
	`653`	`// For these need to find out the ffmpeg names`
0	`654`	`if (string.Equals(codec, "mp2", StringComparison.OrdinalIgnoreCase))`
	`655`	`{`
0	`656`	`return null;`
	`657`	`}`
	`658`
0	`659`	`if (string.Equals(codec, "aac_latm", StringComparison.OrdinalIgnoreCase))`
	`660`	`{`
0	`661`	`return null;`
	`662`	`}`
	`663`
0	`664`	`if (string.Equals(codec, "eac3", StringComparison.OrdinalIgnoreCase))`
	`665`	`{`
0	`666`	`return null;`
	`667`	`}`
	`668`
0	`669`	`if (_mediaEncoder.SupportsDecoder(codec))`
	`670`	`{`
0	`671`	`return codec;`
	`672`	`}`
	`673`
0	`674`	`return null;`
	`675`	`}`
	`676`
	`677`	`/// <summary>`
	`678`	`/// Infers the audio codec based on the url.`
	`679`	`/// </summary>`
	`680`	`/// <param name="container">Container to use.</param>`
	`681`	`/// <returns>Codec string.</returns>`
	`682`	`public string InferAudioCodec(string container)`
	`683`	`{`
0	`684`	`if (string.IsNullOrWhiteSpace(container))`
	`685`	`{`
	`686`	`// this may not work, but if the client is that broken we cannot do anything better`
0	`687`	`return "aac";`
	`688`	`}`
	`689`
0	`690`	`var inferredCodec = container.ToLowerInvariant();`
	`691`
0	`692`	`return inferredCodec switch`
0	`693`	`{`
0	`694`	`"ogg" or "oga" or "ogv" or "webm" or "webma" => "opus",`
0	`695`	`"m4a" or "m4b" or "mp4" or "mov" or "mkv" or "mka" => "aac",`
0	`696`	`"ts" or "avi" or "flv" or "f4v" or "swf" => "mp3",`
0	`697`	`_ => inferredCodec`
0	`698`	`};`
	`699`	`}`
	`700`
	`701`	`/// <summary>`
	`702`	`/// Infers the video codec.`
	`703`	`/// </summary>`
	`704`	`/// <param name="url">The URL.</param>`
	`705`	`/// <returns>System.Nullable{VideoCodecs}.</returns>`
	`706`	`public string InferVideoCodec(string url)`
	`707`	`{`
0	`708`	`var ext = Path.GetExtension(url.AsSpan());`
	`709`
0	`710`	`if (ext.Equals(".asf", StringComparison.OrdinalIgnoreCase))`
	`711`	`{`
0	`712`	`return "wmv";`
	`713`	`}`
	`714`
0	`715`	`if (ext.Equals(".webm", StringComparison.OrdinalIgnoreCase))`
	`716`	`{`
	`717`	`// TODO: this may not always mean VP8, as the codec ages`
0	`718`	`return "vp8";`
	`719`	`}`
	`720`
0	`721`	`if (ext.Equals(".ogg", StringComparison.OrdinalIgnoreCase) \|\| ext.Equals(".ogv", StringComparison.OrdinalIgn`
	`722`	`{`
0	`723`	`return "theora";`
	`724`	`}`
	`725`
0	`726`	`if (ext.Equals(".m3u8", StringComparison.OrdinalIgnoreCase) \|\| ext.Equals(".ts", StringComparison.OrdinalIgn`
	`727`	`{`
0	`728`	`return "h264";`
	`729`	`}`
	`730`
0	`731`	`return "copy";`
	`732`	`}`
	`733`
	`734`	`public int GetVideoProfileScore(string videoCodec, string videoProfile)`
	`735`	`{`
	`736`	`// strip spaces because they may be stripped out on the query string`
0	`737`	`string profile = videoProfile.Replace(" ", string.Empty, StringComparison.Ordinal);`
0	`738`	`if (string.Equals("h264", videoCodec, StringComparison.OrdinalIgnoreCase))`
	`739`	`{`
0	`740`	`return Array.FindIndex(_videoProfilesH264, x => string.Equals(x, profile, StringComparison.OrdinalIgnore`
	`741`	`}`
	`742`
0	`743`	`if (string.Equals("hevc", videoCodec, StringComparison.OrdinalIgnoreCase))`
	`744`	`{`
0	`745`	`return Array.FindIndex(_videoProfilesH265, x => string.Equals(x, profile, StringComparison.OrdinalIgnore`
	`746`	`}`
	`747`
0	`748`	`if (string.Equals("av1", videoCodec, StringComparison.OrdinalIgnoreCase))`
	`749`	`{`
0	`750`	`return Array.FindIndex(_videoProfilesAv1, x => string.Equals(x, profile, StringComparison.OrdinalIgnoreC`
	`751`	`}`
	`752`
0	`753`	`return -1;`
	`754`	`}`
	`755`
	`756`	`/// <summary>`
	`757`	`/// Gets the audio encoder.`
	`758`	`/// </summary>`
	`759`	`/// <param name="state">The state.</param>`
	`760`	`/// <returns>System.String.</returns>`
	`761`	`public string GetAudioEncoder(EncodingJobInfo state)`
	`762`	`{`
0	`763`	`var codec = state.OutputAudioCodec;`
	`764`
0	`765`	`if (!ContainerValidationRegex().IsMatch(codec))`
	`766`	`{`
0	`767`	`codec = "aac";`
	`768`	`}`
	`769`
0	`770`	`if (string.Equals(codec, "aac", StringComparison.OrdinalIgnoreCase))`
	`771`	`{`
	`772`	`// Use Apple's aac encoder if available as it provides best audio quality`
0	`773`	`if (_mediaEncoder.SupportsEncoder("aac_at"))`
	`774`	`{`
0	`775`	`return "aac_at";`
	`776`	`}`
	`777`
	`778`	`// Use libfdk_aac for better audio quality if using custom build of FFmpeg which has fdk_aac support`
0	`779`	`if (_mediaEncoder.SupportsEncoder("libfdk_aac"))`
	`780`	`{`
0	`781`	`return "libfdk_aac";`
	`782`	`}`
	`783`
0	`784`	`return "aac";`
	`785`	`}`
	`786`
0	`787`	`if (string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))`
	`788`	`{`
0	`789`	`return "libmp3lame";`
	`790`	`}`
	`791`
0	`792`	`if (string.Equals(codec, "vorbis", StringComparison.OrdinalIgnoreCase))`
	`793`	`{`
0	`794`	`return "libvorbis";`
	`795`	`}`
	`796`
0	`797`	`if (string.Equals(codec, "opus", StringComparison.OrdinalIgnoreCase))`
	`798`	`{`
0	`799`	`return "libopus";`
	`800`	`}`
	`801`
0	`802`	`if (string.Equals(codec, "flac", StringComparison.OrdinalIgnoreCase))`
	`803`	`{`
0	`804`	`return "flac";`
	`805`	`}`
	`806`
0	`807`	`if (string.Equals(codec, "dts", StringComparison.OrdinalIgnoreCase))`
	`808`	`{`
0	`809`	`return "dca";`
	`810`	`}`
	`811`
0	`812`	`if (string.Equals(codec, "alac", StringComparison.OrdinalIgnoreCase))`
	`813`	`{`
	`814`	`// The ffmpeg upstream breaks the AudioToolbox ALAC encoder in version 6.1 but fixes it in version 7.0.`
	`815`	`// Since ALAC is lossless in quality and the AudioToolbox encoder is not faster,`
	`816`	`// its only benefit is a smaller file size.`
	`817`	`// To prevent problems, use the ffmpeg native encoder instead.`
0	`818`	`return "alac";`
	`819`	`}`
	`820`
0	`821`	`return codec.ToLowerInvariant();`
	`822`	`}`
	`823`
	`824`	`private string GetRkmppDeviceArgs(string alias)`
	`825`	`{`
0	`826`	`alias ??= RkmppAlias;`
	`827`
	`828`	`// device selection in rk is not supported.`
0	`829`	`return " -init_hw_device rkmpp=" + alias;`
	`830`	`}`
	`831`
	`832`	`private string GetVideoToolboxDeviceArgs(string alias)`
	`833`	`{`
0	`834`	`alias ??= VideotoolboxAlias;`
	`835`
	`836`	`// device selection in vt is not supported.`
0	`837`	`return " -init_hw_device videotoolbox=" + alias;`
	`838`	`}`
	`839`
	`840`	`private string GetCudaDeviceArgs(int deviceIndex, string alias)`
	`841`	`{`
0	`842`	`alias ??= CudaAlias;`
0	`843`	`deviceIndex = deviceIndex >= 0`
0	`844`	`? deviceIndex`
0	`845`	`: 0;`
	`846`
0	`847`	`return string.Format(`
0	`848`	`CultureInfo.InvariantCulture,`
0	`849`	`" -init_hw_device cuda={0}:{1}",`
0	`850`	`alias,`
0	`851`	`deviceIndex);`
	`852`	`}`
	`853`
	`854`	`private string GetVulkanDeviceArgs(int deviceIndex, string deviceName, string srcDeviceAlias, string alias)`
	`855`	`{`
0	`856`	`alias ??= VulkanAlias;`
0	`857`	`deviceIndex = deviceIndex >= 0`
0	`858`	`? deviceIndex`
0	`859`	`: 0;`
0	`860`	`var vendorOpts = string.IsNullOrEmpty(deviceName)`
0	`861`	`? ":" + deviceIndex`
0	`862`	`: ":" + "\"" + deviceName + "\"";`
0	`863`	`var options = string.IsNullOrEmpty(srcDeviceAlias)`
0	`864`	`? vendorOpts`
0	`865`	`: "@" + srcDeviceAlias;`
	`866`
0	`867`	`return string.Format(`
0	`868`	`CultureInfo.InvariantCulture,`
0	`869`	`" -init_hw_device vulkan={0}{1}",`
0	`870`	`alias,`
0	`871`	`options);`
	`872`	`}`
	`873`
	`874`	`private string GetOpenclDeviceArgs(int deviceIndex, string deviceVendorName, string srcDeviceAlias, string alias`
	`875`	`{`
0	`876`	`alias ??= OpenclAlias;`
0	`877`	`deviceIndex = deviceIndex >= 0`
0	`878`	`? deviceIndex`
0	`879`	`: 0;`
0	`880`	`var vendorOpts = string.IsNullOrEmpty(deviceVendorName)`
0	`881`	`? ":0.0"`
0	`882`	`: ":." + deviceIndex + ",device_vendor=\"" + deviceVendorName + "\"";`
0	`883`	`var options = string.IsNullOrEmpty(srcDeviceAlias)`
0	`884`	`? vendorOpts`
0	`885`	`: "@" + srcDeviceAlias;`
	`886`
0	`887`	`return string.Format(`
0	`888`	`CultureInfo.InvariantCulture,`
0	`889`	`" -init_hw_device opencl={0}{1}",`
0	`890`	`alias,`
0	`891`	`options);`
	`892`	`}`
	`893`
	`894`	`private string GetD3d11vaDeviceArgs(int deviceIndex, string deviceVendorId, string alias)`
	`895`	`{`
0	`896`	`alias ??= D3d11vaAlias;`
0	`897`	`deviceIndex = deviceIndex >= 0 ? deviceIndex : 0;`
0	`898`	`var options = string.IsNullOrEmpty(deviceVendorId)`
0	`899`	`? deviceIndex.ToString(CultureInfo.InvariantCulture)`
0	`900`	`: ",vendor=" + deviceVendorId;`
	`901`
0	`902`	`return string.Format(`
0	`903`	`CultureInfo.InvariantCulture,`
0	`904`	`" -init_hw_device d3d11va={0}:{1}",`
0	`905`	`alias,`
0	`906`	`options);`
	`907`	`}`
	`908`
	`909`	`private string GetVaapiDeviceArgs(string renderNodePath, string driver, string kernelDriver, string vendorId, st`
	`910`	`{`
0	`911`	`alias ??= VaapiAlias;`
0	`912`	`var haveVendorId = !string.IsNullOrEmpty(vendorId)`
0	`913`	`&& _mediaEncoder.EncoderVersion >= _minFFmpegVaapiDeviceVendorId;`
	`914`
	`915`	`// Priority: 'renderNodePath' > 'vendorId' > 'kernelDriver'`
0	`916`	`var driverOpts = File.Exists(renderNodePath)`
0	`917`	`? renderNodePath`
0	`918`	`: (haveVendorId ? $",vendor_id={vendorId}" : (string.IsNullOrEmpty(kernelDriver) ? string.Empty : $",ker`
	`919`
	`920`	`// 'driver' behaves similarly to env LIBVA_DRIVER_NAME`
0	`921`	`driverOpts += string.IsNullOrEmpty(driver) ? string.Empty : ",driver=" + driver;`
	`922`
0	`923`	`var options = string.IsNullOrEmpty(srcDeviceAlias)`
0	`924`	`? (string.IsNullOrEmpty(driverOpts) ? string.Empty : ":" + driverOpts)`
0	`925`	`: "@" + srcDeviceAlias;`
	`926`
0	`927`	`return string.Format(`
0	`928`	`CultureInfo.InvariantCulture,`
0	`929`	`" -init_hw_device vaapi={0}{1}",`
0	`930`	`alias,`
0	`931`	`options);`
	`932`	`}`
	`933`
	`934`	`private string GetDrmDeviceArgs(string renderNodePath, string alias)`
	`935`	`{`
0	`936`	`alias ??= DrmAlias;`
0	`937`	`renderNodePath = renderNodePath ?? "/dev/dri/renderD128";`
	`938`
0	`939`	`return string.Format(`
0	`940`	`CultureInfo.InvariantCulture,`
0	`941`	`" -init_hw_device drm={0}:{1}",`
0	`942`	`alias,`
0	`943`	`renderNodePath);`
	`944`	`}`
	`945`
	`946`	`private string GetQsvDeviceArgs(string renderNodePath, string alias)`
	`947`	`{`
0	`948`	`var arg = " -init_hw_device qsv=" + (alias ?? QsvAlias);`
0	`949`	`if (OperatingSystem.IsLinux())`
	`950`	`{`
	`951`	`// derive qsv from vaapi device`
0	`952`	`return GetVaapiDeviceArgs(renderNodePath, "iHD", "i915", "0x8086", null, VaapiAlias) + arg + "@" + Vaapi`
	`953`	`}`
	`954`
0	`955`	`if (OperatingSystem.IsWindows())`
	`956`	`{`
	`957`	`// on Windows, the deviceIndex is an int`
0	`958`	`if (int.TryParse(renderNodePath, NumberStyles.Integer, CultureInfo.InvariantCulture, out int deviceIndex`
	`959`	`{`
0	`960`	`return GetD3d11vaDeviceArgs(deviceIndex, string.Empty, D3d11vaAlias) + arg + "@" + D3d11vaAlias;`
	`961`	`}`
	`962`
	`963`	`// derive qsv from d3d11va device`
0	`964`	`return GetD3d11vaDeviceArgs(0, "0x8086", D3d11vaAlias) + arg + "@" + D3d11vaAlias;`
	`965`	`}`
	`966`
0	`967`	`return null;`
	`968`	`}`
	`969`
	`970`	`private string GetFilterHwDeviceArgs(string alias)`
	`971`	`{`
0	`972`	`return string.IsNullOrEmpty(alias)`
0	`973`	`? string.Empty`
0	`974`	`: " -filter_hw_device " + alias;`
	`975`	`}`
	`976`
	`977`	`public string GetGraphicalSubCanvasSize(EncodingJobInfo state)`
	`978`	`{`
	`979`	`// DVBSUB uses the fixed canvas size 720x576`
4	`980`	`if (state.SubtitleStream is not null`
4	`981`	`&& ShouldEncodeSubtitle(state)`
4	`982`	`&& !state.SubtitleStream.IsTextSubtitleStream`
4	`983`	`&& !string.Equals(state.SubtitleStream.Codec, "DVBSUB", StringComparison.OrdinalIgnoreCase))`
	`984`	`{`
2	`985`	`var subtitleWidth = state.SubtitleStream?.Width;`
2	`986`	`var subtitleHeight = state.SubtitleStream?.Height;`
	`987`
2	`988`	`if (subtitleWidth.HasValue`
2	`989`	`&& subtitleHeight.HasValue`
2	`990`	`&& subtitleWidth.Value > 0`
2	`991`	`&& subtitleHeight.Value > 0)`
	`992`	`{`
0	`993`	`return string.Format(`
0	`994`	`CultureInfo.InvariantCulture,`
0	`995`	`" -canvas_size {0}x{1}",`
0	`996`	`subtitleWidth.Value,`
0	`997`	`subtitleHeight.Value);`
	`998`	`}`
	`999`	`}`
	`1000`
4	`1001`	`return string.Empty;`
	`1002`	`}`
	`1003`
	`1004`	`/// <summary>`
	`1005`	`/// Gets the input video hwaccel argument.`
	`1006`	`/// </summary>`
	`1007`	`/// <param name="state">Encoding state.</param>`
	`1008`	`/// <param name="options">Encoding options.</param>`
	`1009`	`/// <returns>Input video hwaccel arguments.</returns>`
	`1010`	`public string GetInputVideoHwaccelArgs(EncodingJobInfo state, EncodingOptions options)`
	`1011`	`{`
4	`1012`	`if (!state.IsVideoRequest)`
	`1013`	`{`
0	`1014`	`return string.Empty;`
	`1015`	`}`
	`1016`
4	`1017`	`var vidEncoder = GetVideoEncoder(state, options) ?? string.Empty;`
4	`1018`	`if (IsCopyCodec(vidEncoder))`
	`1019`	`{`
4	`1020`	`return string.Empty;`
	`1021`	`}`
	`1022`
0	`1023`	`var args = new StringBuilder();`
0	`1024`	`var isWindows = OperatingSystem.IsWindows();`
0	`1025`	`var isLinux = OperatingSystem.IsLinux();`
0	`1026`	`var isMacOS = OperatingSystem.IsMacOS();`
0	`1027`	`var optHwaccelType = options.HardwareAccelerationType;`
0	`1028`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
0	`1029`	`var isHwTonemapAvailable = IsHwTonemapAvailable(state, options);`
	`1030`
0	`1031`	`if (optHwaccelType == HardwareAccelerationType.vaapi)`
	`1032`	`{`
0	`1033`	`if (!isLinux \|\| !_mediaEncoder.SupportsHwaccel("vaapi"))`
	`1034`	`{`
0	`1035`	`return string.Empty;`
	`1036`	`}`
	`1037`
0	`1038`	`var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`1039`	`var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`1040`	`if (!isVaapiDecoder && !isVaapiEncoder)`
	`1041`	`{`
0	`1042`	`return string.Empty;`
	`1043`	`}`
	`1044`
0	`1045`	`if (_mediaEncoder.IsVaapiDeviceInteliHD)`
	`1046`	`{`
0	`1047`	`args.Append(GetVaapiDeviceArgs(options.VaapiDevice, "iHD", null, null, null, VaapiAlias));`
	`1048`	`}`
0	`1049`	`else if (_mediaEncoder.IsVaapiDeviceInteli965)`
	`1050`	`{`
	`1051`	`// Only override i965 since it has lower priority than iHD in libva lookup.`
0	`1052`	`Environment.SetEnvironmentVariable("LIBVA_DRIVER_NAME", "i965");`
0	`1053`	`Environment.SetEnvironmentVariable("LIBVA_DRIVER_NAME_JELLYFIN", "i965");`
0	`1054`	`args.Append(GetVaapiDeviceArgs(options.VaapiDevice, "i965", null, null, null, VaapiAlias));`
	`1055`	`}`
	`1056`
0	`1057`	`var filterDevArgs = string.Empty;`
0	`1058`	`var doOclTonemap = isHwTonemapAvailable && IsOpenclFullSupported();`
	`1059`
0	`1060`	`if (_mediaEncoder.IsVaapiDeviceInteliHD \|\| _mediaEncoder.IsVaapiDeviceInteli965)`
	`1061`	`{`
0	`1062`	`if (doOclTonemap && !isVaapiDecoder)`
	`1063`	`{`
0	`1064`	`args.Append(GetOpenclDeviceArgs(0, null, VaapiAlias, OpenclAlias));`
0	`1065`	`filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);`
	`1066`	`}`
	`1067`	`}`
0	`1068`	`else if (_mediaEncoder.IsVaapiDeviceAmd)`
	`1069`	`{`
	`1070`	`// Disable AMD EFC feature since it's still unstable in upstream Mesa.`
0	`1071`	`Environment.SetEnvironmentVariable("AMD_DEBUG", "noefc");`
	`1072`
0	`1073`	`if (IsVulkanFullSupported()`
0	`1074`	`&& _mediaEncoder.IsVaapiDeviceSupportVulkanDrmInterop`
0	`1075`	`&& Environment.OSVersion.Version >= _minKernelVersionAmdVkFmtModifier)`
	`1076`	`{`
0	`1077`	`args.Append(GetDrmDeviceArgs(options.VaapiDevice, DrmAlias));`
0	`1078`	`args.Append(GetVaapiDeviceArgs(null, null, null, null, DrmAlias, VaapiAlias));`
0	`1079`	`args.Append(GetVulkanDeviceArgs(0, null, DrmAlias, VulkanAlias));`
	`1080`
	`1081`	`// libplacebo wants an explicitly set vulkan filter device.`
0	`1082`	`filterDevArgs = GetFilterHwDeviceArgs(VulkanAlias);`
	`1083`	`}`
	`1084`	`else`
	`1085`	`{`
0	`1086`	`args.Append(GetVaapiDeviceArgs(options.VaapiDevice, null, null, null, null, VaapiAlias));`
0	`1087`	`filterDevArgs = GetFilterHwDeviceArgs(VaapiAlias);`
	`1088`
0	`1089`	`if (doOclTonemap)`
	`1090`	`{`
	`1091`	`// ROCm/ROCr OpenCL runtime`
0	`1092`	`args.Append(GetOpenclDeviceArgs(0, "Advanced Micro Devices", null, OpenclAlias));`
0	`1093`	`filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);`
	`1094`	`}`
	`1095`	`}`
	`1096`	`}`
0	`1097`	`else if (doOclTonemap)`
	`1098`	`{`
0	`1099`	`args.Append(GetOpenclDeviceArgs(0, null, null, OpenclAlias));`
0	`1100`	`filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);`
	`1101`	`}`
	`1102`
0	`1103`	`args.Append(filterDevArgs);`
	`1104`	`}`
0	`1105`	`else if (optHwaccelType == HardwareAccelerationType.qsv)`
	`1106`	`{`
0	`1107`	`if ((!isLinux && !isWindows) \|\| !_mediaEncoder.SupportsHwaccel("qsv"))`
	`1108`	`{`
0	`1109`	`return string.Empty;`
	`1110`	`}`
	`1111`
0	`1112`	`var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);`
0	`1113`	`var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`1114`	`var isQsvDecoder = vidDecoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);`
0	`1115`	`var isQsvEncoder = vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);`
0	`1116`	`var isHwDecoder = isQsvDecoder \|\| isVaapiDecoder \|\| isD3d11vaDecoder;`
0	`1117`	`if (!isHwDecoder && !isQsvEncoder)`
	`1118`	`{`
0	`1119`	`return string.Empty;`
	`1120`	`}`
	`1121`
0	`1122`	`args.Append(GetQsvDeviceArgs(options.QsvDevice, QsvAlias));`
0	`1123`	`var filterDevArgs = GetFilterHwDeviceArgs(QsvAlias);`
	`1124`	`// child device used by qsv.`
0	`1125`	`if (_mediaEncoder.SupportsHwaccel("vaapi") \|\| _mediaEncoder.SupportsHwaccel("d3d11va"))`
	`1126`	`{`
0	`1127`	`if (isHwTonemapAvailable && IsOpenclFullSupported())`
	`1128`	`{`
0	`1129`	`var srcAlias = isLinux ? VaapiAlias : D3d11vaAlias;`
0	`1130`	`args.Append(GetOpenclDeviceArgs(0, null, srcAlias, OpenclAlias));`
0	`1131`	`if (!isHwDecoder)`
	`1132`	`{`
0	`1133`	`filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);`
	`1134`	`}`
	`1135`	`}`
	`1136`	`}`
	`1137`
0	`1138`	`args.Append(filterDevArgs);`
	`1139`	`}`
0	`1140`	`else if (optHwaccelType == HardwareAccelerationType.nvenc)`
	`1141`	`{`
0	`1142`	`if ((!isLinux && !isWindows) \|\| !IsCudaFullSupported())`
	`1143`	`{`
0	`1144`	`return string.Empty;`
	`1145`	`}`
	`1146`
0	`1147`	`var isCuvidDecoder = vidDecoder.Contains("cuvid", StringComparison.OrdinalIgnoreCase);`
0	`1148`	`var isNvdecDecoder = vidDecoder.Contains("cuda", StringComparison.OrdinalIgnoreCase);`
0	`1149`	`var isNvencEncoder = vidEncoder.Contains("nvenc", StringComparison.OrdinalIgnoreCase);`
0	`1150`	`var isHwDecoder = isNvdecDecoder \|\| isCuvidDecoder;`
0	`1151`	`if (!isHwDecoder && !isNvencEncoder)`
	`1152`	`{`
0	`1153`	`return string.Empty;`
	`1154`	`}`
	`1155`
0	`1156`	`args.Append(GetCudaDeviceArgs(0, CudaAlias))`
0	`1157`	`.Append(GetFilterHwDeviceArgs(CudaAlias));`
	`1158`	`}`
0	`1159`	`else if (optHwaccelType == HardwareAccelerationType.amf)`
	`1160`	`{`
0	`1161`	`if (!isWindows \|\| !_mediaEncoder.SupportsHwaccel("d3d11va"))`
	`1162`	`{`
0	`1163`	`return string.Empty;`
	`1164`	`}`
	`1165`
0	`1166`	`var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);`
0	`1167`	`var isAmfEncoder = vidEncoder.Contains("amf", StringComparison.OrdinalIgnoreCase);`
0	`1168`	`if (!isD3d11vaDecoder && !isAmfEncoder)`
	`1169`	`{`
0	`1170`	`return string.Empty;`
	`1171`	`}`
	`1172`
	`1173`	`// no dxva video processor hw filter.`
0	`1174`	`args.Append(GetD3d11vaDeviceArgs(0, "0x1002", D3d11vaAlias));`
0	`1175`	`var filterDevArgs = string.Empty;`
0	`1176`	`if (IsOpenclFullSupported())`
	`1177`	`{`
0	`1178`	`args.Append(GetOpenclDeviceArgs(0, null, D3d11vaAlias, OpenclAlias));`
0	`1179`	`filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);`
	`1180`	`}`
	`1181`
0	`1182`	`args.Append(filterDevArgs);`
	`1183`	`}`
0	`1184`	`else if (optHwaccelType == HardwareAccelerationType.videotoolbox)`
	`1185`	`{`
0	`1186`	`if (!isMacOS \|\| !_mediaEncoder.SupportsHwaccel("videotoolbox"))`
	`1187`	`{`
0	`1188`	`return string.Empty;`
	`1189`	`}`
	`1190`
0	`1191`	`var isVideotoolboxDecoder = vidDecoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);`
0	`1192`	`var isVideotoolboxEncoder = vidEncoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);`
0	`1193`	`if (!isVideotoolboxDecoder && !isVideotoolboxEncoder)`
	`1194`	`{`
0	`1195`	`return string.Empty;`
	`1196`	`}`
	`1197`
	`1198`	`// videotoolbox hw filter does not require device selection`
0	`1199`	`args.Append(GetVideoToolboxDeviceArgs(VideotoolboxAlias));`
	`1200`	`}`
0	`1201`	`else if (optHwaccelType == HardwareAccelerationType.rkmpp)`
	`1202`	`{`
0	`1203`	`if (!isLinux \|\| !_mediaEncoder.SupportsHwaccel("rkmpp"))`
	`1204`	`{`
0	`1205`	`return string.Empty;`
	`1206`	`}`
	`1207`
0	`1208`	`var isRkmppDecoder = vidDecoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);`
0	`1209`	`var isRkmppEncoder = vidEncoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);`
0	`1210`	`if (!isRkmppDecoder && !isRkmppEncoder)`
	`1211`	`{`
0	`1212`	`return string.Empty;`
	`1213`	`}`
	`1214`
0	`1215`	`args.Append(GetRkmppDeviceArgs(RkmppAlias));`
	`1216`
0	`1217`	`var filterDevArgs = string.Empty;`
0	`1218`	`var doOclTonemap = isHwTonemapAvailable && IsOpenclFullSupported();`
	`1219`
0	`1220`	`if (doOclTonemap && !isRkmppDecoder)`
	`1221`	`{`
0	`1222`	`args.Append(GetOpenclDeviceArgs(0, null, RkmppAlias, OpenclAlias));`
0	`1223`	`filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);`
	`1224`	`}`
	`1225`
0	`1226`	`args.Append(filterDevArgs);`
	`1227`	`}`
	`1228`
0	`1229`	`if (!string.IsNullOrEmpty(vidDecoder))`
	`1230`	`{`
0	`1231`	`args.Append(vidDecoder);`
	`1232`	`}`
	`1233`
0	`1234`	`return args.ToString().Trim();`
	`1235`	`}`
	`1236`
	`1237`	`/// <summary>`
	`1238`	`/// Gets the input argument.`
	`1239`	`/// </summary>`
	`1240`	`/// <param name="state">Encoding state.</param>`
	`1241`	`/// <param name="options">Encoding options.</param>`
	`1242`	`/// <param name="segmentContainer">Segment Container.</param>`
	`1243`	`/// <returns>Input arguments.</returns>`
	`1244`	`public string GetInputArgument(EncodingJobInfo state, EncodingOptions options, string segmentContainer)`
	`1245`	`{`
4	`1246`	`var arg = new StringBuilder();`
4	`1247`	`var inputVidHwaccelArgs = GetInputVideoHwaccelArgs(state, options);`
	`1248`
4	`1249`	`if (!string.IsNullOrEmpty(inputVidHwaccelArgs))`
	`1250`	`{`
0	`1251`	`arg.Append(inputVidHwaccelArgs);`
	`1252`	`}`
	`1253`
4	`1254`	`var canvasArgs = GetGraphicalSubCanvasSize(state);`
4	`1255`	`if (!string.IsNullOrEmpty(canvasArgs))`
	`1256`	`{`
0	`1257`	`arg.Append(canvasArgs);`
	`1258`	`}`
	`1259`
4	`1260`	`if (state.MediaSource.VideoType == VideoType.Dvd \|\| state.MediaSource.VideoType == VideoType.BluRay)`
	`1261`	`{`
0	`1262`	`var concatFilePath = Path.Join(_configurationManager.CommonApplicationPaths.CachePath, "concat", state.M`
0	`1263`	`if (!File.Exists(concatFilePath))`
	`1264`	`{`
0	`1265`	`_mediaEncoder.GenerateConcatConfig(state.MediaSource, concatFilePath);`
	`1266`	`}`
	`1267`
0	`1268`	`arg.Append(" -f concat -safe 0 -i \"")`
0	`1269`	`.Append(concatFilePath)`
0	`1270`	`.Append("\" ");`
	`1271`	`}`
	`1272`	`else`
	`1273`	`{`
4	`1274`	`arg.Append(" -i ")`
4	`1275`	`.Append(_mediaEncoder.GetInputPathArgument(state));`
	`1276`	`}`
	`1277`
4	`1278`	`if (NeedsExternalSubtitleMuxing(state))`
	`1279`	`{`
4	`1280`	`var subtitlePath = state.SubtitleStream.Path;`
4	`1281`	`var isGraphicalBurnIn = ShouldEncodeSubtitle(state) && !state.SubtitleStream.IsTextSubtitleStream;`
	`1282`
	`1283`	`// dvdsub/vobsub graphical subtitles use .sub+.idx pairs`
4	`1284`	`var subtitleExtension = Path.GetExtension(subtitlePath.AsSpan());`
4	`1285`	`if (subtitleExtension.Equals(".sub", StringComparison.OrdinalIgnoreCase))`
	`1286`	`{`
4	`1287`	`var idxFile = Path.ChangeExtension(subtitlePath, ".idx");`
4	`1288`	`if (File.Exists(idxFile))`
	`1289`	`{`
2	`1290`	`subtitlePath = idxFile;`
	`1291`	`}`
	`1292`	`}`
	`1293`
	`1294`	`// Use analyzeduration also for subtitle streams to improve resolution detection with streams inside MK`
4	`1295`	`var analyzeDurationArgument = GetFfmpegAnalyzeDurationArg(state);`
4	`1296`	`if (!string.IsNullOrEmpty(analyzeDurationArgument))`
	`1297`	`{`
0	`1298`	`arg.Append(' ').Append(analyzeDurationArgument);`
	`1299`	`}`
	`1300`
	`1301`	`// Apply probesize, too, if configured`
4	`1302`	`var ffmpegProbeSizeArgument = GetFfmpegProbesizeArg();`
4	`1303`	`if (!string.IsNullOrEmpty(ffmpegProbeSizeArgument))`
	`1304`	`{`
0	`1305`	`arg.Append(' ').Append(ffmpegProbeSizeArgument);`
	`1306`	`}`
	`1307`
	`1308`	`// Also seek the external subtitles stream.`
4	`1309`	`var seekSubParam = GetFastSeekCommandLineParameter(state, options, segmentContainer);`
4	`1310`	`if (!string.IsNullOrEmpty(seekSubParam))`
	`1311`	`{`
0	`1312`	`arg.Append(' ').Append(seekSubParam);`
	`1313`	`}`
	`1314`
4	`1315`	`if (isGraphicalBurnIn && !string.IsNullOrEmpty(canvasArgs))`
	`1316`	`{`
0	`1317`	`arg.Append(canvasArgs);`
	`1318`	`}`
	`1319`
4	`1320`	`arg.Append(" -i file:\"").Append(subtitlePath).Append('\"');`
	`1321`	`}`
	`1322`
4	`1323`	`if (state.AudioStream is not null && state.AudioStream.IsExternal)`
	`1324`	`{`
	`1325`	`// Also seek the external audio stream.`
0	`1326`	`var seekAudioParam = GetFastSeekCommandLineParameter(state, options, segmentContainer);`
0	`1327`	`if (!string.IsNullOrEmpty(seekAudioParam))`
	`1328`	`{`
0	`1329`	`arg.Append(' ').Append(seekAudioParam);`
	`1330`	`}`
	`1331`
0	`1332`	`arg.Append(" -i \"").Append(state.AudioStream.Path).Append('"');`
	`1333`	`}`
	`1334`
	`1335`	`// Disable auto inserted SW scaler for HW decoders in case of changed resolution.`
4	`1336`	`var isSwDecoder = string.IsNullOrEmpty(GetHardwareVideoDecoder(state, options));`
4	`1337`	`if (!isSwDecoder)`
	`1338`	`{`
0	`1339`	`arg.Append(" -noautoscale");`
	`1340`	`}`
	`1341`
4	`1342`	`return arg.ToString();`
	`1343`	`}`
	`1344`
	`1345`	`/// <summary>`
	`1346`	`/// Determines whether the specified stream is H264.`
	`1347`	`/// </summary>`
	`1348`	`/// <param name="stream">The stream.</param>`
	`1349`	`/// <returns><c>true</c> if the specified stream is H264; otherwise, <c>false</c>.</returns>`
	`1350`	`public static bool IsH264(MediaStream stream)`
	`1351`	`{`
0	`1352`	`var codec = stream.Codec ?? string.Empty;`
	`1353`
0	`1354`	`return codec.Contains("264", StringComparison.OrdinalIgnoreCase)`
0	`1355`	`\|\| codec.Contains("avc", StringComparison.OrdinalIgnoreCase);`
	`1356`	`}`
	`1357`
	`1358`	`public static bool IsH265(MediaStream stream)`
	`1359`	`{`
0	`1360`	`var codec = stream.Codec ?? string.Empty;`
	`1361`
0	`1362`	`return codec.Contains("265", StringComparison.OrdinalIgnoreCase)`
0	`1363`	`\|\| codec.Contains("hevc", StringComparison.OrdinalIgnoreCase);`
	`1364`	`}`
	`1365`
	`1366`	`public static bool IsAv1(MediaStream stream)`
	`1367`	`{`
0	`1368`	`var codec = stream.Codec ?? string.Empty;`
	`1369`
0	`1370`	`return codec.Contains("av1", StringComparison.OrdinalIgnoreCase);`
	`1371`	`}`
	`1372`
	`1373`	`public static bool IsAAC(MediaStream stream)`
	`1374`	`{`
10	`1375`	`var codec = stream.Codec ?? string.Empty;`
	`1376`
10	`1377`	`return codec.Contains("aac", StringComparison.OrdinalIgnoreCase);`
	`1378`	`}`
	`1379`
	`1380`	`public static bool IsDoviWithHdr10Bl(MediaStream stream)`
	`1381`	`{`
0	`1382`	`var rangeType = stream?.VideoRangeType;`
	`1383`
0	`1384`	`return rangeType is VideoRangeType.DOVIWithHDR10`
0	`1385`	`or VideoRangeType.DOVIWithEL`
0	`1386`	`or VideoRangeType.DOVIWithHDR10Plus`
0	`1387`	`or VideoRangeType.DOVIWithELHDR10Plus`
0	`1388`	`or VideoRangeType.DOVIInvalid;`
	`1389`	`}`
	`1390`
	`1391`	`public static bool IsDovi(MediaStream stream)`
	`1392`	`{`
0	`1393`	`var rangeType = stream?.VideoRangeType;`
	`1394`
0	`1395`	`return IsDoviWithHdr10Bl(stream)`
0	`1396`	`\|\| (rangeType is VideoRangeType.DOVI`
0	`1397`	`or VideoRangeType.DOVIWithHLG`
0	`1398`	`or VideoRangeType.DOVIWithSDR);`
	`1399`	`}`
	`1400`
	`1401`	`public static bool IsHdr10Plus(MediaStream stream)`
	`1402`	`{`
0	`1403`	`var rangeType = stream?.VideoRangeType;`
	`1404`
0	`1405`	`return rangeType is VideoRangeType.HDR10Plus`
0	`1406`	`or VideoRangeType.DOVIWithHDR10Plus`
0	`1407`	`or VideoRangeType.DOVIWithELHDR10Plus;`
	`1408`	`}`
	`1409`
	`1410`	`/// <summary>`
	`1411`	`/// Check if dynamic HDR metadata should be removed during stream copy.`
	`1412`	`/// Please note this check assumes the range check has already been done`
	`1413`	`/// and trivial fallbacks like HDR10+ to HDR10, DOVIWithHDR10 to HDR10 is already checked.`
	`1414`	`/// </summary>`
	`1415`	`private static DynamicHdrMetadataRemovalPlan ShouldRemoveDynamicHdrMetadata(EncodingJobInfo state)`
	`1416`	`{`
0	`1417`	`var videoStream = state.VideoStream;`
0	`1418`	`if (videoStream.VideoRange is not VideoRange.HDR)`
	`1419`	`{`
0	`1420`	`return DynamicHdrMetadataRemovalPlan.None;`
	`1421`	`}`
	`1422`
0	`1423`	`var requestedRangeTypes = state.GetRequestedRangeTypes(state.VideoStream.Codec);`
0	`1424`	`if (requestedRangeTypes.Length == 0)`
	`1425`	`{`
0	`1426`	`return DynamicHdrMetadataRemovalPlan.None;`
	`1427`	`}`
	`1428`
0	`1429`	`var requestHasHDR10 = requestedRangeTypes.Contains(VideoRangeType.HDR10.ToString(), StringComparison.Ordinal`
0	`1430`	`var requestHasDOVI = requestedRangeTypes.Contains(VideoRangeType.DOVI.ToString(), StringComparison.OrdinalIg`
0	`1431`	`var requestHasDOVIwithEL = requestedRangeTypes.Contains(VideoRangeType.DOVIWithEL.ToString(), StringComparis`
0	`1432`	`var requestHasDOVIwithELHDR10plus = requestedRangeTypes.Contains(VideoRangeType.DOVIWithELHDR10Plus.ToString`
	`1433`
0	`1434`	`var shouldRemoveHdr10Plus = false;`
	`1435`	`// Case 1: Client supports HDR10, does not support DOVI with EL but EL presets`
0	`1436`	`var shouldRemoveDovi = (!requestHasDOVIwithEL && requestHasHDR10) && videoStream.VideoRangeType == VideoRang`
	`1437`
	`1438`	`// Case 2: Client supports DOVI, does not support broken DOVI config`
	`1439`	`// Client does not report DOVI support should be allowed to copy bad data for remuxing as HDR10 players woul`
0	`1440`	`shouldRemoveDovi = shouldRemoveDovi \|\| (requestHasDOVI && videoStream.VideoRangeType == VideoRangeType.DOVII`
	`1441`
	`1442`	`// Special case: we have a video with both EL and HDR10+`
	`1443`	`// If the client supports EL but not in the case of coexistence with HDR10+, remove HDR10+ for compatibility`
	`1444`	`// Otherwise, remove DOVI if the client is not a DOVI player`
0	`1445`	`if (videoStream.VideoRangeType == VideoRangeType.DOVIWithELHDR10Plus)`
	`1446`	`{`
0	`1447`	`shouldRemoveHdr10Plus = requestHasDOVIwithEL && !requestHasDOVIwithELHDR10plus;`
0	`1448`	`shouldRemoveDovi = shouldRemoveDovi \|\| !shouldRemoveHdr10Plus;`
	`1449`	`}`
	`1450`
0	`1451`	`if (shouldRemoveDovi)`
	`1452`	`{`
0	`1453`	`return DynamicHdrMetadataRemovalPlan.RemoveDovi;`
	`1454`	`}`
	`1455`
	`1456`	`// If the client is a Dolby Vision Player, remove the HDR10+ metadata to avoid playback issues`
0	`1457`	`shouldRemoveHdr10Plus = shouldRemoveHdr10Plus \|\| (requestHasDOVI && videoStream.VideoRangeType == VideoRange`
0	`1458`	`return shouldRemoveHdr10Plus ? DynamicHdrMetadataRemovalPlan.RemoveHdr10Plus : DynamicHdrMetadataRemovalPlan`
	`1459`	`}`
	`1460`
	`1461`	`private bool CanEncoderRemoveDynamicHdrMetadata(DynamicHdrMetadataRemovalPlan plan, MediaStream videoStream)`
	`1462`	`{`
0	`1463`	`return plan switch`
0	`1464`	`{`
0	`1465`	`DynamicHdrMetadataRemovalPlan.RemoveDovi => _mediaEncoder.SupportsBitStreamFilterWithOption(BitStreamFil`
0	`1466`	`\|\| (IsH265(videoStream) && _mediaEncoder.SupportsBitStreamFi`
0	`1467`	`\|\| (IsAv1(videoStream) && _mediaEncoder.SupportsBitStreamFil`
0	`1468`	`DynamicHdrMetadataRemovalPlan.RemoveHdr10Plus => (IsH265(videoStream) && _mediaEncoder.SupportsBitStream`
0	`1469`	`\|\| (IsAv1(videoStream) && _mediaEncoder.SupportsBitStre`
0	`1470`	`_ => true,`
0	`1471`	`};`
	`1472`	`}`
	`1473`
	`1474`	`public bool IsDoviRemoved(EncodingJobInfo state)`
	`1475`	`{`
0	`1476`	`return state?.VideoStream is not null && ShouldRemoveDynamicHdrMetadata(state) == DynamicHdrMetadataRemovalP`
0	`1477`	`&& CanEncoderRemoveDynamicHdrMetadata(DynamicHdrMetadataRemovalPlan.Remove`
	`1478`	`}`
	`1479`
	`1480`	`public bool IsHdr10PlusRemoved(EncodingJobInfo state)`
	`1481`	`{`
0	`1482`	`return state?.VideoStream is not null && ShouldRemoveDynamicHdrMetadata(state) == DynamicHdrMetadataRemovalP`
0	`1483`	`&& CanEncoderRemoveDynamicHdrMetadata(DynamicHdrMetadataRemovalPlan.Re`
	`1484`	`}`
	`1485`
	`1486`	`public string GetBitStreamArgs(EncodingJobInfo state, MediaStreamType streamType)`
	`1487`	`{`
0	`1488`	`if (state is null)`
	`1489`	`{`
0	`1490`	`return null;`
	`1491`	`}`
	`1492`
0	`1493`	`var stream = streamType switch`
0	`1494`	`{`
0	`1495`	`MediaStreamType.Audio => state.AudioStream,`
0	`1496`	`MediaStreamType.Video => state.VideoStream,`
0	`1497`	`_ => state.VideoStream`
0	`1498`	`};`
	`1499`	`// TODO This is auto inserted into the mpegts mux so it might not be needed.`
	`1500`	`// https://www.ffmpeg.org/ffmpeg-bitstream-filters.html#h264_005fmp4toannexb`
0	`1501`	`if (IsH264(stream))`
	`1502`	`{`
0	`1503`	`return "-bsf:v h264_mp4toannexb";`
	`1504`	`}`
	`1505`
0	`1506`	`if (IsAAC(stream))`
	`1507`	`{`
	`1508`	`// Convert adts header(mpegts) to asc header(mp4).`
0	`1509`	`return "-bsf:a aac_adtstoasc";`
	`1510`	`}`
	`1511`
0	`1512`	`if (IsH265(stream))`
	`1513`	`{`
0	`1514`	`var filter = "-bsf:v hevc_mp4toannexb";`
	`1515`
	`1516`	`// The following checks are not complete because the copy would be rejected`
	`1517`	`// if the encoder cannot remove required metadata.`
	`1518`	`// And if bsf is used, we must already be using copy codec.`
0	`1519`	`switch (ShouldRemoveDynamicHdrMetadata(state))`
	`1520`	`{`
	`1521`	`default:`
	`1522`	`case DynamicHdrMetadataRemovalPlan.None:`
	`1523`	`break;`
	`1524`	`case DynamicHdrMetadataRemovalPlan.RemoveDovi:`
0	`1525`	`filter += _mediaEncoder.SupportsBitStreamFilterWithOption(BitStreamFilterOptionType.HevcMetadata`
0	`1526`	`? ",hevc_metadata=remove_dovi=1"`
0	`1527`	`: ",dovi_rpu=strip=1";`
0	`1528`	`break;`
	`1529`	`case DynamicHdrMetadataRemovalPlan.RemoveHdr10Plus:`
0	`1530`	`filter += ",hevc_metadata=remove_hdr10plus=1";`
	`1531`	`break;`
	`1532`	`}`
	`1533`
0	`1534`	`return filter;`
	`1535`	`}`
	`1536`
0	`1537`	`if (IsAv1(stream))`
	`1538`	`{`
0	`1539`	`switch (ShouldRemoveDynamicHdrMetadata(state))`
	`1540`	`{`
	`1541`	`default:`
	`1542`	`case DynamicHdrMetadataRemovalPlan.None:`
0	`1543`	`return null;`
	`1544`	`case DynamicHdrMetadataRemovalPlan.RemoveDovi:`
0	`1545`	`return _mediaEncoder.SupportsBitStreamFilterWithOption(BitStreamFilterOptionType.Av1MetadataRemo`
0	`1546`	`? "-bsf:v av1_metadata=remove_dovi=1"`
0	`1547`	`: "-bsf:v dovi_rpu=strip=1";`
	`1548`	`case DynamicHdrMetadataRemovalPlan.RemoveHdr10Plus:`
0	`1549`	`return "-bsf:v av1_metadata=remove_hdr10plus=1";`
	`1550`	`}`
	`1551`	`}`
	`1552`
0	`1553`	`return null;`
	`1554`	`}`
	`1555`
	`1556`	`public string GetAudioBitStreamArguments(EncodingJobInfo state, string segmentContainer, string mediaSourceConta`
	`1557`	`{`
12	`1558`	`var filters = new List<string>();`
	`1559`
12	`1560`	`var noiseFilter = GetCopiedAudioTrimBsf(state);`
12	`1561`	`if (!string.IsNullOrEmpty(noiseFilter))`
	`1562`	`{`
6	`1563`	`filters.Add(noiseFilter);`
	`1564`	`}`
	`1565`
12	`1566`	`var segmentFormat = GetSegmentFileExtension(segmentContainer).TrimStart('.');`
	`1567`
	`1568`	`// Apply aac_adtstoasc bitstream filter when media source is in mpegts.`
12	`1569`	`if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase)`
12	`1570`	`&& (string.Equals(mediaSourceContainer, "ts", StringComparison.OrdinalIgnoreCase)`
12	`1571`	`\|\| string.Equals(mediaSourceContainer, "aac", StringComparison.OrdinalIgnoreCase)`
12	`1572`	`\|\| string.Equals(mediaSourceContainer, "hls", StringComparison.OrdinalIgnoreCase))`
12	`1573`	`&& IsAAC(state.AudioStream))`
	`1574`	`{`
9	`1575`	`filters.Add("aac_adtstoasc");`
	`1576`	`}`
	`1577`
12	`1578`	`return filters.Count == 0`
12	`1579`	`? string.Empty`
12	`1580`	`: " -bsf:a " + string.Join(',', filters);`
	`1581`	`}`
	`1582`
	`1583`	`// When video is transcoded, accurate_seek (the default) trims video to the`
	`1584`	`// exact seek point via decoder-side frame discard. But stream-copied audio`
	`1585`	`// bypasses the decoder, so it starts from the nearest keyframe — potentially`
	`1586`	`// seconds before the target. Use the noise bsf to drop copied audio packets`
	`1587`	`// before the seek target, achieving the same trim precision without`
	`1588`	`// re-encoding. The noise bsf's drop= parameter requires ffmpeg >= 5.0.`
	`1589`	`// Important: make sure not to use it with wtv because it breaks seeking`
	`1590`	`private string GetCopiedAudioTrimBsf(EncodingJobInfo state)`
	`1591`	`{`
12	`1592`	`if (state.TranscodingType is not TranscodingJobType.Hls`
12	`1593`	`\|\| !state.IsVideoRequest`
12	`1594`	`\|\| IsCopyCodec(state.OutputVideoCodec)`
12	`1595`	`\|\| !IsCopyCodec(state.OutputAudioCodec)`
12	`1596`	`\|\| string.Equals(state.InputContainer, "wtv", StringComparison.OrdinalIgnoreCase)`
12	`1597`	`\|\| _mediaEncoder.EncoderVersion < _minFFmpegNoiseBsfDrop)`
	`1598`	`{`
5	`1599`	`return null;`
	`1600`	`}`
	`1601`
7	`1602`	`var startTicks = state.BaseRequest.StartTimeTicks ?? 0;`
7	`1603`	`if (startTicks <= 0)`
	`1604`	`{`
1	`1605`	`return null;`
	`1606`	`}`
	`1607`
6	`1608`	`var seekSeconds = startTicks / (double)TimeSpan.TicksPerSecond;`
6	`1609`	`return string.Format(`
6	`1610`	`CultureInfo.InvariantCulture,`
6	`1611`	`"noise=drop='lt(pts*tb\\,{0:F3})'",`
6	`1612`	`seekSeconds);`
	`1613`	`}`
	`1614`
	`1615`	`public static string GetSegmentFileExtension(string segmentContainer)`
	`1616`	`{`
12	`1617`	`if (!string.IsNullOrWhiteSpace(segmentContainer))`
	`1618`	`{`
12	`1619`	`return "." + segmentContainer;`
	`1620`	`}`
	`1621`
0	`1622`	`return ".ts";`
	`1623`	`}`
	`1624`
	`1625`	`private string GetVideoBitrateParam(EncodingJobInfo state, string videoCodec)`
	`1626`	`{`
0	`1627`	`if (state.OutputVideoBitrate is null)`
	`1628`	`{`
0	`1629`	`return string.Empty;`
	`1630`	`}`
	`1631`
0	`1632`	`int bitrate = state.OutputVideoBitrate.Value;`
	`1633`
	`1634`	`// Bit rate under 1000k is not allowed in h264_qsv.`
0	`1635`	`if (string.Equals(videoCodec, "h264_qsv", StringComparison.OrdinalIgnoreCase))`
	`1636`	`{`
0	`1637`	`bitrate = Math.Max(bitrate, 1000);`
	`1638`	`}`
	`1639`
	`1640`	`// Currently use the same buffer size for all non-QSV encoders.`
	`1641`	`// Use long arithmetic to prevent int32 overflow for very high bitrate values.`
0	`1642`	`int bufsize = (int)Math.Min((long)bitrate * 2, int.MaxValue);`
	`1643`
0	`1644`	`if (string.Equals(videoCodec, "libsvtav1", StringComparison.OrdinalIgnoreCase))`
	`1645`	`{`
0	`1646`	`return FormattableString.Invariant($" -b:v {bitrate} -bufsize {bufsize}");`
	`1647`	`}`
	`1648`
0	`1649`	`if (string.Equals(videoCodec, "libx264", StringComparison.OrdinalIgnoreCase)`
0	`1650`	`\|\| string.Equals(videoCodec, "libx265", StringComparison.OrdinalIgnoreCase))`
	`1651`	`{`
0	`1652`	`return FormattableString.Invariant($" -maxrate {bitrate} -bufsize {bufsize}");`
	`1653`	`}`
	`1654`
0	`1655`	`if (string.Equals(videoCodec, "h264_qsv", StringComparison.OrdinalIgnoreCase)`
0	`1656`	`\|\| string.Equals(videoCodec, "hevc_qsv", StringComparison.OrdinalIgnoreCase)`
0	`1657`	`\|\| string.Equals(videoCodec, "av1_qsv", StringComparison.OrdinalIgnoreCase))`
	`1658`	`{`
	`1659`	`// TODO: probe QSV encoders' capabilities and enable more tuning options`
	`1660`	`// See also https://github.com/intel/media-delivery/blob/master/doc/quality.rst`
	`1661`
	`1662`	`// Enable MacroBlock level bitrate control for better subjective visual quality`
0	`1663`	`var mbbrcOpt = string.Empty;`
0	`1664`	`if (string.Equals(videoCodec, "h264_qsv", StringComparison.OrdinalIgnoreCase)`
0	`1665`	`\|\| string.Equals(videoCodec, "hevc_qsv", StringComparison.OrdinalIgnoreCase))`
	`1666`	`{`
0	`1667`	`mbbrcOpt = " -mbbrc 1";`
	`1668`	`}`
	`1669`
	`1670`	`// Some less powerful H.264 HW decoders require strict CPB size`
	`1671`	`// So bufsize optimizations should not be applied to them`
0	`1672`	`int factor = 2;`
0	`1673`	`var codec = state.ActualOutputVideoCodec;`
0	`1674`	`var level = state.GetRequestedLevel(codec);`
0	`1675`	`if (string.Equals(codec, "h264", StringComparison.OrdinalIgnoreCase)`
0	`1676`	`&& double.TryParse(level, CultureInfo.InvariantCulture, out double requestedLevel)`
0	`1677`	`&& requestedLevel < 51)`
	`1678`	`{`
0	`1679`	`factor = 1;`
	`1680`	`}`
	`1681`
	`1682`	`// Set (maxrate == bitrate + 1) to trigger VBR for better bitrate allocation`
	`1683`	`// Set (rc_init_occupancy == 2 * bitrate) and (bufsize == 4 * bitrate) to deal with drastic scene change`
	`1684`	`// Use long arithmetic and clamp to int.MaxValue to prevent int32 overflow`
	`1685`	`// (e.g. bitrate * 4 wraps to a negative value for bitrates above ~537 million)`
0	`1686`	`int qsvMaxrate = (int)Math.Min((long)bitrate + 1, int.MaxValue);`
0	`1687`	`int qsvInitOcc = (int)Math.Min((long)bitrate * 1 * factor, int.MaxValue);`
0	`1688`	`int qsvBufsize = (int)Math.Min((long)bitrate * 2 * factor, int.MaxValue);`
	`1689`
0	`1690`	`return FormattableString.Invariant($"{mbbrcOpt} -b:v {bitrate} -maxrate {qsvMaxrate} -rc_init_occupancy`
	`1691`	`}`
	`1692`
0	`1693`	`if (string.Equals(videoCodec, "h264_amf", StringComparison.OrdinalIgnoreCase)`
0	`1694`	`\|\| string.Equals(videoCodec, "hevc_amf", StringComparison.OrdinalIgnoreCase))`
	`1695`	`{`
	`1696`	`// Override the too high default qmin 18 in transcoding preset in legacy h26x_amf`
0	`1697`	`return FormattableString.Invariant($" -rc cbr -qmin 0 -qmax 32 -b:v {bitrate} -maxrate {bitrate} -bufsiz`
	`1698`	`}`
	`1699`
0	`1700`	`if (string.Equals(videoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`1701`	`\|\| string.Equals(videoCodec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`1702`	`\|\| string.Equals(videoCodec, "av1_vaapi", StringComparison.OrdinalIgnoreCase))`
	`1703`	`{`
	`1704`	`// VBR in i965 driver may result in pixelated output.`
0	`1705`	`if (_mediaEncoder.IsVaapiDeviceInteli965)`
	`1706`	`{`
0	`1707`	`return FormattableString.Invariant($" -rc_mode CBR -b:v {bitrate} -maxrate {bitrate} -bufsize {bufsi`
	`1708`	`}`
	`1709`
0	`1710`	`return FormattableString.Invariant($" -rc_mode VBR -b:v {bitrate} -maxrate {bitrate} -bufsize {bufsize}"`
	`1711`	`}`
	`1712`
0	`1713`	`if (string.Equals(videoCodec, "h264_videotoolbox", StringComparison.OrdinalIgnoreCase)`
0	`1714`	`\|\| string.Equals(videoCodec, "hevc_videotoolbox", StringComparison.OrdinalIgnoreCase))`
	`1715`	`{`
	`1716`	// The `maxrate` and `bufsize` options can potentially lead to performance regression
	`1717`	`// and even encoder hangs, especially when the value is very high.`
0	`1718`	`return FormattableString.Invariant($" -b:v {bitrate} -qmin -1 -qmax -1");`
	`1719`	`}`
	`1720`
0	`1721`	`return FormattableString.Invariant($" -b:v {bitrate} -maxrate {bitrate} -bufsize {bufsize}");`
	`1722`	`}`
	`1723`
	`1724`	`private string GetEncoderParam(EncoderPreset? preset, EncoderPreset defaultPreset, EncodingOptions encodingOptio`
	`1725`	`{`
0	`1726`	`var param = string.Empty;`
0	`1727`	`var encoderPreset = preset ?? defaultPreset;`
0	`1728`	`if (string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase) \|\| isLibX265)`
	`1729`	`{`
0	`1730`	`var presetString = encoderPreset switch`
0	`1731`	`{`
0	`1732`	`EncoderPreset.auto => EncoderPreset.veryfast.ToString().ToLowerInvariant(),`
0	`1733`	`_ => encoderPreset.ToString().ToLowerInvariant()`
0	`1734`	`};`
	`1735`
0	`1736`	`param += " -preset " + presetString;`
	`1737`
0	`1738`	`int encodeCrf = encodingOptions.H264Crf;`
0	`1739`	`if (isLibX265)`
	`1740`	`{`
0	`1741`	`encodeCrf = encodingOptions.H265Crf;`
	`1742`	`}`
	`1743`
0	`1744`	`if (encodeCrf >= 0 && encodeCrf <= 51)`
	`1745`	`{`
0	`1746`	`param += " -crf " + encodeCrf.ToString(CultureInfo.InvariantCulture);`
	`1747`	`}`
	`1748`	`else`
	`1749`	`{`
0	`1750`	`string defaultCrf = "23";`
0	`1751`	`if (isLibX265)`
	`1752`	`{`
0	`1753`	`defaultCrf = "28";`
	`1754`	`}`
	`1755`
0	`1756`	`param += " -crf " + defaultCrf;`
	`1757`	`}`
	`1758`	`}`
0	`1759`	`else if (string.Equals(videoEncoder, "libsvtav1", StringComparison.OrdinalIgnoreCase))`
	`1760`	`{`
	`1761`	`// Default to use the recommended preset 10.`
	`1762`	`// Omit presets < 5, which are too slow for on the fly encoding.`
	`1763`	`// https://gitlab.com/AOMediaCodec/SVT-AV1/-/blob/master/Docs/Ffmpeg.md`
0	`1764`	`param += encoderPreset switch`
0	`1765`	`{`
0	`1766`	`EncoderPreset.veryslow => " -preset 5",`
0	`1767`	`EncoderPreset.slower => " -preset 6",`
0	`1768`	`EncoderPreset.slow => " -preset 7",`
0	`1769`	`EncoderPreset.medium => " -preset 8",`
0	`1770`	`EncoderPreset.fast => " -preset 9",`
0	`1771`	`EncoderPreset.faster => " -preset 10",`
0	`1772`	`EncoderPreset.veryfast => " -preset 11",`
0	`1773`	`EncoderPreset.superfast => " -preset 12",`
0	`1774`	`EncoderPreset.ultrafast => " -preset 13",`
0	`1775`	`_ => " -preset 10"`
0	`1776`	`};`
	`1777`	`}`
0	`1778`	`else if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`1779`	`\|\| string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`1780`	`\|\| string.Equals(videoEncoder, "av1_vaapi", StringComparison.OrdinalIgnoreCase))`
	`1781`	`{`
	`1782`	`// -compression_level is not reliable on AMD.`
0	`1783`	`if (_mediaEncoder.IsVaapiDeviceInteliHD)`
	`1784`	`{`
0	`1785`	`param += encoderPreset switch`
0	`1786`	`{`
0	`1787`	`EncoderPreset.veryslow => " -compression_level 1",`
0	`1788`	`EncoderPreset.slower => " -compression_level 2",`
0	`1789`	`EncoderPreset.slow => " -compression_level 3",`
0	`1790`	`EncoderPreset.medium => " -compression_level 4",`
0	`1791`	`EncoderPreset.fast => " -compression_level 5",`
0	`1792`	`EncoderPreset.faster => " -compression_level 6",`
0	`1793`	`EncoderPreset.veryfast => " -compression_level 7",`
0	`1794`	`EncoderPreset.superfast => " -compression_level 7",`
0	`1795`	`EncoderPreset.ultrafast => " -compression_level 7",`
0	`1796`	`_ => string.Empty`
0	`1797`	`};`
	`1798`	`}`
	`1799`	`}`
0	`1800`	`else if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase) // h264 (h264_qsv)`
0	`1801`	`\|\| string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase) // hevc (hevc_qsv)`
0	`1802`	`\|\| string.Equals(videoEncoder, "av1_qsv", StringComparison.OrdinalIgnoreCase)) // av1 (av1_qsv)`
	`1803`	`{`
0	`1804`	`EncoderPreset[] valid_presets = [EncoderPreset.veryslow, EncoderPreset.slower, EncoderPreset.slow, Encod`
	`1805`
0	`1806`	`param += " -preset " + (valid_presets.Contains(encoderPreset) ? encoderPreset : EncoderPreset.veryfast).`
	`1807`	`}`
0	`1808`	`else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase) // h264 (h264_nvenc)`
0	`1809`	`\|\| string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase) // hevc (hevc_n`
0	`1810`	`\|\| string.Equals(videoEncoder, "av1_nvenc", StringComparison.OrdinalIgnoreCase) // av1 (av1_nven`
0	`1811`	`)`
	`1812`	`{`
0	`1813`	`param += encoderPreset switch`
0	`1814`	`{`
0	`1815`	`EncoderPreset.veryslow => " -preset p7",`
0	`1816`	`EncoderPreset.slower => " -preset p6",`
0	`1817`	`EncoderPreset.slow => " -preset p5",`
0	`1818`	`EncoderPreset.medium => " -preset p4",`
0	`1819`	`EncoderPreset.fast => " -preset p3",`
0	`1820`	`EncoderPreset.faster => " -preset p2",`
0	`1821`	`_ => " -preset p1"`
0	`1822`	`};`
	`1823`	`}`
0	`1824`	`else if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase) // h264 (h264_amf)`
0	`1825`	`\|\| string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase) // hevc (hevc_amf`
0	`1826`	`\|\| string.Equals(videoEncoder, "av1_amf", StringComparison.OrdinalIgnoreCase) // av1 (av1_amf)`
0	`1827`	`)`
	`1828`	`{`
0	`1829`	`param += encoderPreset switch`
0	`1830`	`{`
0	`1831`	`EncoderPreset.veryslow => " -quality quality",`
0	`1832`	`EncoderPreset.slower => " -quality quality",`
0	`1833`	`EncoderPreset.slow => " -quality quality",`
0	`1834`	`EncoderPreset.medium => " -quality balanced",`
0	`1835`	`_ => " -quality speed"`
0	`1836`	`};`
	`1837`
0	`1838`	`if (string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase)`
0	`1839`	`\|\| string.Equals(videoEncoder, "av1_amf", StringComparison.OrdinalIgnoreCase))`
	`1840`	`{`
0	`1841`	`param += " -header_insertion_mode gop";`
	`1842`	`}`
	`1843`
0	`1844`	`if (string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase))`
	`1845`	`{`
0	`1846`	`param += " -gops_per_idr 1";`
	`1847`	`}`
	`1848`	`}`
0	`1849`	`else if (string.Equals(videoEncoder, "h264_videotoolbox", StringComparison.OrdinalIgnoreCase) // h264 (h264_`
0	`1850`	`\|\| string.Equals(videoEncoder, "hevc_videotoolbox", StringComparison.OrdinalIgnoreCase) // hevc`
0	`1851`	`)`
	`1852`	`{`
0	`1853`	`param += encoderPreset switch`
0	`1854`	`{`
0	`1855`	`EncoderPreset.veryslow => " -prio_speed 0",`
0	`1856`	`EncoderPreset.slower => " -prio_speed 0",`
0	`1857`	`EncoderPreset.slow => " -prio_speed 0",`
0	`1858`	`EncoderPreset.medium => " -prio_speed 0",`
0	`1859`	`_ => " -prio_speed 1"`
0	`1860`	`};`
	`1861`	`}`
	`1862`
0	`1863`	`return param;`
	`1864`	`}`
	`1865`
	`1866`	`public static string NormalizeTranscodingLevel(EncodingJobInfo state, string level)`
	`1867`	`{`
0	`1868`	`if (!double.TryParse(level, CultureInfo.InvariantCulture, out double requestLevel))`
	`1869`	`{`
0	`1870`	`return null;`
	`1871`	`}`
	`1872`
0	`1873`	`if (string.Equals(state.ActualOutputVideoCodec, "av1", StringComparison.OrdinalIgnoreCase))`
	`1874`	`{`
	`1875`	`// Transcode to level 5.3 (15) and lower for maximum compatibility.`
	`1876`	`// https://en.wikipedia.org/wiki/AV1#Levels`
0	`1877`	`if (requestLevel < 0 \|\| requestLevel >= 15)`
	`1878`	`{`
0	`1879`	`return "15";`
	`1880`	`}`
	`1881`	`}`
0	`1882`	`else if (string.Equals(state.ActualOutputVideoCodec, "hevc", StringComparison.OrdinalIgnoreCase)`
0	`1883`	`\|\| string.Equals(state.ActualOutputVideoCodec, "h265", StringComparison.OrdinalIgnoreCase))`
	`1884`	`{`
	`1885`	`// Transcode to level 5.0 and lower for maximum compatibility.`
	`1886`	`// Level 5.0 is suitable for up to 4k 30fps hevc encoding, otherwise let the encoder to handle it.`
	`1887`	`// https://en.wikipedia.org/wiki/High_Efficiency_Video_Coding_tiers_and_levels`
	`1888`	`// MaxLumaSampleRate = 3840216030 = 248832000 < 267386880.`
0	`1889`	`if (requestLevel < 0 \|\| requestLevel >= 150)`
	`1890`	`{`
0	`1891`	`return "150";`
	`1892`	`}`
	`1893`	`}`
0	`1894`	`else if (string.Equals(state.ActualOutputVideoCodec, "h264", StringComparison.OrdinalIgnoreCase))`
	`1895`	`{`
	`1896`	`// Transcode to level 5.1 and lower for maximum compatibility.`
	`1897`	`// h264 4k 30fps requires at least level 5.1 otherwise it will break on safari fmp4.`
	`1898`	`// https://en.wikipedia.org/wiki/Advanced_Video_Coding#Levels`
0	`1899`	`if (requestLevel < 0 \|\| requestLevel >= 51)`
	`1900`	`{`
0	`1901`	`return "51";`
	`1902`	`}`
	`1903`	`}`
	`1904`
0	`1905`	`return level;`
	`1906`	`}`
	`1907`
	`1908`	`/// <summary>`
	`1909`	`/// Gets the text subtitle param.`
	`1910`	`/// </summary>`
	`1911`	`/// <param name="state">The state.</param>`
	`1912`	`/// <param name="enableAlpha">Enable alpha processing.</param>`
	`1913`	`/// <param name="enableSub2video">Enable sub2video mode.</param>`
	`1914`	`/// <returns>System.String.</returns>`
	`1915`	`public string GetTextSubtitlesFilter(EncodingJobInfo state, bool enableAlpha, bool enableSub2video)`
	`1916`	`{`
0	`1917`	`var seconds = Math.Round(TimeSpan.FromTicks(state.StartTimeTicks ?? 0).TotalSeconds);`
	`1918`
	`1919`	`// hls always copies timestamps`
0	`1920`	`var setPtsParam = state.CopyTimestamps \|\| state.TranscodingType != TranscodingJobType.Progressive`
0	`1921`	`? string.Empty`
0	`1922`	`: string.Format(CultureInfo.InvariantCulture, ",setpts=PTS -{0}/TB", seconds);`
	`1923`
0	`1924`	`var alphaParam = enableAlpha ? ":alpha=1" : string.Empty;`
0	`1925`	`var sub2videoParam = enableSub2video ? ":sub2video=1" : string.Empty;`
	`1926`
0	`1927`	`var fontPath = _pathManager.GetAttachmentFolderPath(state.MediaSource.Id);`
0	`1928`	`var fontParam = fontPath is null`
0	`1929`	`? string.Empty`
0	`1930`	`: string.Format(`
0	`1931`	`CultureInfo.InvariantCulture,`
0	`1932`	`":fontsdir='{0}'",`
0	`1933`	`_mediaEncoder.EscapeSubtitleFilterPath(fontPath));`
	`1934`
0	`1935`	`if (state.SubtitleStream.IsExternal)`
	`1936`	`{`
0	`1937`	`var charsetParam = string.Empty;`
	`1938`
0	`1939`	`if (!string.IsNullOrEmpty(state.SubtitleStream.Language))`
	`1940`	`{`
0	`1941`	`var charenc = _subtitleEncoder.GetSubtitleFileCharacterSet(`
0	`1942`	`state.SubtitleStream,`
0	`1943`	`state.SubtitleStream.Language,`
0	`1944`	`state.MediaSource,`
0	`1945`	`CancellationToken.None).GetAwaiter().GetResult();`
	`1946`
0	`1947`	`if (!string.IsNullOrEmpty(charenc))`
	`1948`	`{`
0	`1949`	`charsetParam = ":charenc=" + charenc;`
	`1950`	`}`
	`1951`	`}`
	`1952`
0	`1953`	`return string.Format(`
0	`1954`	`CultureInfo.InvariantCulture,`
0	`1955`	`"subtitles=f='{0}'{1}{2}{3}{4}{5}",`
0	`1956`	`_mediaEncoder.EscapeSubtitleFilterPath(state.SubtitleStream.Path),`
0	`1957`	`charsetParam,`
0	`1958`	`alphaParam,`
0	`1959`	`sub2videoParam,`
0	`1960`	`fontParam,`
0	`1961`	`setPtsParam);`
	`1962`	`}`
	`1963`
0	`1964`	`var subtitlePath = _subtitleEncoder.GetSubtitleFilePath(`
0	`1965`	`state.SubtitleStream,`
0	`1966`	`state.MediaSource,`
0	`1967`	`CancellationToken.None).GetAwaiter().GetResult();`
	`1968`
0	`1969`	`return string.Format(`
0	`1970`	`CultureInfo.InvariantCulture,`
0	`1971`	`"subtitles=f='{0}'{1}{2}{3}{4}",`
0	`1972`	`_mediaEncoder.EscapeSubtitleFilterPath(subtitlePath),`
0	`1973`	`alphaParam,`
0	`1974`	`sub2videoParam,`
0	`1975`	`fontParam,`
0	`1976`	`setPtsParam);`
	`1977`	`}`
	`1978`
	`1979`	`public double? GetFramerateParam(EncodingJobInfo state)`
	`1980`	`{`
0	`1981`	`var request = state.BaseRequest;`
	`1982`
0	`1983`	`if (request.Framerate.HasValue)`
	`1984`	`{`
0	`1985`	`return request.Framerate.Value;`
	`1986`	`}`
	`1987`
0	`1988`	`var maxrate = request.MaxFramerate;`
	`1989`
0	`1990`	`if (maxrate.HasValue && state.VideoStream is not null)`
	`1991`	`{`
0	`1992`	`var contentRate = state.VideoStream.ReferenceFrameRate;`
	`1993`
0	`1994`	`if (contentRate.HasValue && contentRate.Value > maxrate.Value)`
	`1995`	`{`
0	`1996`	`return maxrate;`
	`1997`	`}`
	`1998`	`}`
	`1999`
0	`2000`	`return null;`
	`2001`	`}`
	`2002`
	`2003`	`public string GetHlsVideoKeyFrameArguments(`
	`2004`	`EncodingJobInfo state,`
	`2005`	`string codec,`
	`2006`	`int segmentLength,`
	`2007`	`bool isEventPlaylist,`
	`2008`	`int? startNumber)`
	`2009`	`{`
0	`2010`	`var args = string.Empty;`
0	`2011`	`var gopArg = string.Empty;`
	`2012`
0	`2013`	`var keyFrameArg = string.Format(`
0	`2014`	`CultureInfo.InvariantCulture,`
0	`2015`	`" -force_key_frames:0 \"expr:gte(t,n_forced*{0})\"",`
0	`2016`	`segmentLength);`
	`2017`
0	`2018`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`2019`	`if (framerate.HasValue)`
	`2020`	`{`
	`2021`	`// This is to make sure keyframe interval is limited to our segment,`
	`2022`	`// as forcing keyframes is not enough.`
	`2023`	`// Example: we encoded half of desired length, then codec detected`
	`2024`	`// scene cut and inserted a keyframe; next forced keyframe would`
	`2025`	`// be created outside of segment, which breaks seeking.`
0	`2026`	`gopArg = string.Format(`
0	`2027`	`CultureInfo.InvariantCulture,`
0	`2028`	`" -g:v:0 {0} -keyint_min:v:0 {0}",`
0	`2029`	`Math.Ceiling(segmentLength * framerate.Value));`
	`2030`	`}`
	`2031`
	`2032`	`// Unable to force key frames using these encoders, set key frames by GOP.`
0	`2033`	`if (string.Equals(codec, "h264_qsv", StringComparison.OrdinalIgnoreCase)`
0	`2034`	`\|\| string.Equals(codec, "h264_nvenc", StringComparison.OrdinalIgnoreCase)`
0	`2035`	`\|\| string.Equals(codec, "h264_amf", StringComparison.OrdinalIgnoreCase)`
0	`2036`	`\|\| string.Equals(codec, "h264_rkmpp", StringComparison.OrdinalIgnoreCase)`
0	`2037`	`\|\| string.Equals(codec, "hevc_qsv", StringComparison.OrdinalIgnoreCase)`
0	`2038`	`\|\| string.Equals(codec, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)`
0	`2039`	`\|\| string.Equals(codec, "hevc_rkmpp", StringComparison.OrdinalIgnoreCase)`
0	`2040`	`\|\| string.Equals(codec, "av1_qsv", StringComparison.OrdinalIgnoreCase)`
0	`2041`	`\|\| string.Equals(codec, "av1_nvenc", StringComparison.OrdinalIgnoreCase)`
0	`2042`	`\|\| string.Equals(codec, "av1_amf", StringComparison.OrdinalIgnoreCase)`
0	`2043`	`\|\| string.Equals(codec, "libsvtav1", StringComparison.OrdinalIgnoreCase))`
	`2044`	`{`
0	`2045`	`args += gopArg;`
	`2046`	`}`
0	`2047`	`else if (string.Equals(codec, "libx264", StringComparison.OrdinalIgnoreCase)`
0	`2048`	`\|\| string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase)`
0	`2049`	`\|\| string.Equals(codec, "h264_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`2050`	`\|\| string.Equals(codec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`2051`	`\|\| string.Equals(codec, "av1_vaapi", StringComparison.OrdinalIgnoreCase))`
	`2052`	`{`
0	`2053`	`args += keyFrameArg;`
	`2054`
	`2055`	`// prevent the libx264 from post processing to break the set keyframe.`
0	`2056`	`if (string.Equals(codec, "libx264", StringComparison.OrdinalIgnoreCase))`
	`2057`	`{`
0	`2058`	`args += " -sc_threshold:v:0 0";`
	`2059`	`}`
	`2060`	`}`
	`2061`	`else`
	`2062`	`{`
0	`2063`	`args += keyFrameArg + gopArg;`
	`2064`	`}`
	`2065`
	`2066`	`// The in-band Parameter Sets generated by the AMD HEVC VA-API encoder is inconsistent`
	`2067`	`// with the extradata generated by ffmpeg, causing decoding failures when using hvc1.`
0	`2068`	`if (string.Equals(codec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`2069`	`&& _mediaEncoder.IsVaapiDeviceAmd)`
	`2070`	`{`
	`2071`	`// Extracting the extradata from the in-band PS to bypass the issue.`
	`2072`	`// This can be removed once the issue is resolved in libva or Mesa.`
	`2073`	`// Transcoding is unavoidable here, so using BSF will not conflict with BSF in remuxing.`
0	`2074`	`args += " -flags:v -global_header -bsf:v extract_extradata=remove=0";`
	`2075`	`}`
	`2076`
0	`2077`	`return args;`
	`2078`	`}`
	`2079`
	`2080`	`/// <summary>`
	`2081`	`/// Gets the video bitrate to specify on the command line.`
	`2082`	`/// </summary>`
	`2083`	`/// <param name="state">Encoding state.</param>`
	`2084`	`/// <param name="videoEncoder">Video encoder to use.</param>`
	`2085`	`/// <param name="encodingOptions">Encoding options.</param>`
	`2086`	`/// <param name="defaultPreset">Default present to use for encoding.</param>`
	`2087`	`/// <returns>Video bitrate.</returns>`
	`2088`	`public string GetVideoQualityParam(EncodingJobInfo state, string videoEncoder, EncodingOptions encodingOptions,`
	`2089`	`{`
0	`2090`	`var param = string.Empty;`
	`2091`
	`2092`	`// Tutorials: Enable Intel GuC / HuC firmware loading for Low Power Encoding.`
	`2093`	`// https://01.org/group/43/downloads/firmware`
	`2094`	`// https://wiki.archlinux.org/title/intel_graphics#Enable_GuC_/_HuC_firmware_loading`
	`2095`	`// Intel Low Power Encoding can save unnecessary CPU-GPU synchronization,`
	`2096`	`// which will reduce overhead in performance intensive tasks such as 4k transcoding and tonemapping.`
0	`2097`	`var intelLowPowerHwEncoding = false;`
	`2098`
	`2099`	`// Workaround for linux 5.18 to 6.1.3 i915 hang at cost of performance.`
	`2100`	`// https://github.com/intel/media-driver/issues/1456`
0	`2101`	`var enableWaFori915Hang = false;`
	`2102`
0	`2103`	`var hardwareAccelerationType = encodingOptions.HardwareAccelerationType;`
	`2104`
0	`2105`	`if (hardwareAccelerationType == HardwareAccelerationType.vaapi)`
	`2106`	`{`
0	`2107`	`var isIntelVaapiDriver = _mediaEncoder.IsVaapiDeviceInteliHD \|\| _mediaEncoder.IsVaapiDeviceInteli965;`
	`2108`
0	`2109`	`if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase))`
	`2110`	`{`
0	`2111`	`intelLowPowerHwEncoding = encodingOptions.EnableIntelLowPowerH264HwEncoder && isIntelVaapiDriver;`
	`2112`	`}`
0	`2113`	`else if (string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase))`
	`2114`	`{`
0	`2115`	`intelLowPowerHwEncoding = encodingOptions.EnableIntelLowPowerHevcHwEncoder && isIntelVaapiDriver;`
	`2116`	`}`
	`2117`	`}`
0	`2118`	`else if (hardwareAccelerationType == HardwareAccelerationType.qsv)`
	`2119`	`{`
0	`2120`	`if (OperatingSystem.IsLinux())`
	`2121`	`{`
0	`2122`	`var ver = Environment.OSVersion.Version;`
0	`2123`	`var isFixedKernel60 = ver.Major == 6 && ver.Minor == 0 && ver >= _minFixedKernel60i915Hang;`
0	`2124`	`var isUnaffectedKernel = ver < _minKerneli915Hang \|\| ver > _maxKerneli915Hang;`
	`2125`
0	`2126`	`if (!(isUnaffectedKernel \|\| isFixedKernel60))`
	`2127`	`{`
0	`2128`	`var vidDecoder = GetHardwareVideoDecoder(state, encodingOptions) ?? string.Empty;`
0	`2129`	`var isIntelDecoder = vidDecoder.Contains("qsv", StringComparison.OrdinalIgnoreCase)`
0	`2130`	`\|\| vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`2131`	`var doOclTonemap = _mediaEncoder.SupportsHwaccel("qsv")`
0	`2132`	`&& IsVaapiSupported(state)`
0	`2133`	`&& IsOpenclFullSupported()`
0	`2134`	`&& !IsIntelVppTonemapAvailable(state, encodingOptions)`
0	`2135`	`&& IsHwTonemapAvailable(state, encodingOptions);`
	`2136`
0	`2137`	`enableWaFori915Hang = isIntelDecoder && doOclTonemap;`
	`2138`	`}`
	`2139`	`}`
	`2140`
0	`2141`	`if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase))`
	`2142`	`{`
0	`2143`	`intelLowPowerHwEncoding = encodingOptions.EnableIntelLowPowerH264HwEncoder;`
	`2144`	`}`
0	`2145`	`else if (string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase))`
	`2146`	`{`
0	`2147`	`intelLowPowerHwEncoding = encodingOptions.EnableIntelLowPowerHevcHwEncoder;`
	`2148`	`}`
	`2149`	`else`
	`2150`	`{`
0	`2151`	`enableWaFori915Hang = false;`
	`2152`	`}`
	`2153`	`}`
	`2154`
0	`2155`	`if (intelLowPowerHwEncoding)`
	`2156`	`{`
0	`2157`	`param += " -low_power 1";`
	`2158`	`}`
	`2159`
0	`2160`	`if (enableWaFori915Hang)`
	`2161`	`{`
0	`2162`	`param += " -async_depth 1";`
	`2163`	`}`
	`2164`
0	`2165`	`var isLibX265 = string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase);`
0	`2166`	`var encodingPreset = encodingOptions.EncoderPreset;`
	`2167`
0	`2168`	`param += GetEncoderParam(encodingPreset, defaultPreset, encodingOptions, videoEncoder, isLibX265);`
0	`2169`	`param += GetVideoBitrateParam(state, videoEncoder);`
	`2170`
0	`2171`	`var framerate = GetFramerateParam(state);`
0	`2172`	`if (framerate.HasValue)`
	`2173`	`{`
0	`2174`	`param += string.Format(CultureInfo.InvariantCulture, " -r {0}", framerate.Value.ToString(CultureInfo.Inv`
	`2175`	`}`
	`2176`
0	`2177`	`var targetVideoCodec = state.ActualOutputVideoCodec;`
0	`2178`	`if (string.Equals(targetVideoCodec, "h265", StringComparison.OrdinalIgnoreCase)`
0	`2179`	`\|\| string.Equals(targetVideoCodec, "hevc", StringComparison.OrdinalIgnoreCase))`
	`2180`	`{`
0	`2181`	`targetVideoCodec = "hevc";`
	`2182`	`}`
	`2183`
0	`2184`	`var profile = state.GetRequestedProfiles(targetVideoCodec).FirstOrDefault() ?? string.Empty;`
0	`2185`	`profile = WhiteSpaceRegex().Replace(profile, string.Empty).ToLowerInvariant();`
	`2186`
0	`2187`	`var videoProfiles = Array.Empty<string>();`
0	`2188`	`if (string.Equals("h264", targetVideoCodec, StringComparison.OrdinalIgnoreCase))`
	`2189`	`{`
0	`2190`	`videoProfiles = _videoProfilesH264;`
	`2191`	`}`
0	`2192`	`else if (string.Equals("hevc", targetVideoCodec, StringComparison.OrdinalIgnoreCase))`
	`2193`	`{`
0	`2194`	`videoProfiles = _videoProfilesH265;`
	`2195`	`}`
0	`2196`	`else if (string.Equals("av1", targetVideoCodec, StringComparison.OrdinalIgnoreCase))`
	`2197`	`{`
0	`2198`	`videoProfiles = _videoProfilesAv1;`
	`2199`	`}`
	`2200`
0	`2201`	`if (!videoProfiles.Contains(profile, StringComparison.OrdinalIgnoreCase))`
	`2202`	`{`
0	`2203`	`profile = string.Empty;`
	`2204`	`}`
	`2205`
	`2206`	`// We only transcode to HEVC 8-bit for now, force Main Profile.`
0	`2207`	`if (profile.Contains("main10", StringComparison.OrdinalIgnoreCase)`
0	`2208`	`\|\| profile.Contains("mainstill", StringComparison.OrdinalIgnoreCase))`
	`2209`	`{`
0	`2210`	`profile = "main";`
	`2211`	`}`
	`2212`
	`2213`	`// Extended Profile is not supported by any known h264 encoders, force Main Profile.`
0	`2214`	`if (profile.Contains("extended", StringComparison.OrdinalIgnoreCase))`
	`2215`	`{`
0	`2216`	`profile = "main";`
	`2217`	`}`
	`2218`
	`2219`	`// Only libx264 support encoding H264 High 10 Profile, otherwise force High Profile.`
0	`2220`	`if (!string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase)`
0	`2221`	`&& profile.Contains("high10", StringComparison.OrdinalIgnoreCase))`
	`2222`	`{`
0	`2223`	`profile = "high";`
	`2224`	`}`
	`2225`
	`2226`	`// We only need Main profile of AV1 encoders.`
0	`2227`	`if (videoEncoder.Contains("av1", StringComparison.OrdinalIgnoreCase)`
0	`2228`	`&& (profile.Contains("high", StringComparison.OrdinalIgnoreCase)`
0	`2229`	`\|\| profile.Contains("professional", StringComparison.OrdinalIgnoreCase)))`
	`2230`	`{`
0	`2231`	`profile = "main";`
	`2232`	`}`
	`2233`
	`2234`	`// h264_vaapi does not support Baseline profile, force Constrained Baseline in this case,`
	`2235`	`// which is compatible (and ugly).`
0	`2236`	`if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`2237`	`&& profile.Contains("baseline", StringComparison.OrdinalIgnoreCase))`
	`2238`	`{`
0	`2239`	`profile = "constrained_baseline";`
	`2240`	`}`
	`2241`
	`2242`	`// libx264, h264_{qsv,nvenc,rkmpp} does not support Constrained Baseline profile, force Baseline in this cas`
0	`2243`	`if ((string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase)`
0	`2244`	`\|\| string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)`
0	`2245`	`\|\| string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)`
0	`2246`	`\|\| string.Equals(videoEncoder, "h264_rkmpp", StringComparison.OrdinalIgnoreCase))`
0	`2247`	`&& profile.Contains("baseline", StringComparison.OrdinalIgnoreCase))`
	`2248`	`{`
0	`2249`	`profile = "baseline";`
	`2250`	`}`
	`2251`
	`2252`	`// libx264, h264_{qsv,nvenc,vaapi,rkmpp} does not support Constrained High profile, force High in this case.`
0	`2253`	`if ((string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase)`
0	`2254`	`\|\| string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)`
0	`2255`	`\|\| string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)`
0	`2256`	`\|\| string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`2257`	`\|\| string.Equals(videoEncoder, "h264_rkmpp", StringComparison.OrdinalIgnoreCase))`
0	`2258`	`&& profile.Contains("high", StringComparison.OrdinalIgnoreCase))`
	`2259`	`{`
0	`2260`	`profile = "high";`
	`2261`	`}`
	`2262`
0	`2263`	`if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)`
0	`2264`	`&& profile.Contains("baseline", StringComparison.OrdinalIgnoreCase))`
	`2265`	`{`
0	`2266`	`profile = "constrained_baseline";`
	`2267`	`}`
	`2268`
0	`2269`	`if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)`
0	`2270`	`&& profile.Contains("constrainedhigh", StringComparison.OrdinalIgnoreCase))`
	`2271`	`{`
0	`2272`	`profile = "constrained_high";`
	`2273`	`}`
	`2274`
0	`2275`	`if (string.Equals(videoEncoder, "h264_videotoolbox", StringComparison.OrdinalIgnoreCase)`
0	`2276`	`&& profile.Contains("constrainedbaseline", StringComparison.OrdinalIgnoreCase))`
	`2277`	`{`
0	`2278`	`profile = "constrained_baseline";`
	`2279`	`}`
	`2280`
0	`2281`	`if (string.Equals(videoEncoder, "h264_videotoolbox", StringComparison.OrdinalIgnoreCase)`
0	`2282`	`&& profile.Contains("constrainedhigh", StringComparison.OrdinalIgnoreCase))`
	`2283`	`{`
0	`2284`	`profile = "constrained_high";`
	`2285`	`}`
	`2286`
0	`2287`	`if (!string.IsNullOrEmpty(profile))`
	`2288`	`{`
	`2289`	`// Currently there's no profile option in av1_nvenc encoder`
0	`2290`	`if (!(string.Equals(videoEncoder, "av1_nvenc", StringComparison.OrdinalIgnoreCase)`
0	`2291`	`\|\| string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase)))`
	`2292`	`{`
0	`2293`	`param += " -profile:v:0 " + profile;`
	`2294`	`}`
	`2295`	`}`
	`2296`
0	`2297`	`var level = NormalizeTranscodingLevel(state, state.GetRequestedLevel(targetVideoCodec));`
	`2298`
0	`2299`	`if (!string.IsNullOrEmpty(level))`
	`2300`	`{`
	`2301`	`// libx264, QSV, AMF can adjust the given level to match the output.`
0	`2302`	`if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)`
0	`2303`	`\|\| string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase))`
	`2304`	`{`
0	`2305`	`param += " -level " + level;`
	`2306`	`}`
0	`2307`	`else if (string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase))`
	`2308`	`{`
	`2309`	`// hevc_qsv use -level 51 instead of -level 153.`
0	`2310`	`if (double.TryParse(level, CultureInfo.InvariantCulture, out double hevcLevel))`
	`2311`	`{`
0	`2312`	`param += " -level " + (hevcLevel / 3);`
	`2313`	`}`
	`2314`	`}`
0	`2315`	`else if (string.Equals(videoEncoder, "av1_qsv", StringComparison.OrdinalIgnoreCase)`
0	`2316`	`\|\| string.Equals(videoEncoder, "libsvtav1", StringComparison.OrdinalIgnoreCase))`
	`2317`	`{`
	`2318`	`// libsvtav1 and av1_qsv use -level 60 instead of -level 16`
	`2319`	`// https://aomedia.org/av1/specification/annex-a/`
0	`2320`	`if (int.TryParse(level, NumberStyles.Any, CultureInfo.InvariantCulture, out int av1Level))`
	`2321`	`{`
0	`2322`	`var x = 2 + (av1Level >> 2);`
0	`2323`	`var y = av1Level & 3;`
0	`2324`	`var res = (x * 10) + y;`
0	`2325`	`param += " -level " + res;`
	`2326`	`}`
	`2327`	`}`
0	`2328`	`else if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)`
0	`2329`	`\|\| string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase)`
0	`2330`	`\|\| string.Equals(videoEncoder, "av1_amf", StringComparison.OrdinalIgnoreCase))`
	`2331`	`{`
0	`2332`	`param += " -level " + level;`
	`2333`	`}`
0	`2334`	`else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)`
0	`2335`	`\|\| string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)`
0	`2336`	`\|\| string.Equals(videoEncoder, "av1_nvenc", StringComparison.OrdinalIgnoreCase))`
	`2337`	`{`
	`2338`	`// level option may cause NVENC to fail.`
	`2339`	`// NVENC cannot adjust the given level, just throw an error.`
	`2340`	`}`
0	`2341`	`else if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`2342`	`\|\| string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)`
0	`2343`	`\|\| string.Equals(videoEncoder, "av1_vaapi", StringComparison.OrdinalIgnoreCase))`
	`2344`	`{`
	`2345`	`// level option may cause corrupted frames on AMD VAAPI.`
0	`2346`	`if (_mediaEncoder.IsVaapiDeviceInteliHD \|\| _mediaEncoder.IsVaapiDeviceInteli965)`
	`2347`	`{`
0	`2348`	`param += " -level " + level;`
	`2349`	`}`
	`2350`	`}`
0	`2351`	`else if (string.Equals(videoEncoder, "h264_rkmpp", StringComparison.OrdinalIgnoreCase)`
0	`2352`	`\|\| string.Equals(videoEncoder, "hevc_rkmpp", StringComparison.OrdinalIgnoreCase))`
	`2353`	`{`
0	`2354`	`param += " -level " + level;`
	`2355`	`}`
0	`2356`	`else if (!string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase))`
	`2357`	`{`
0	`2358`	`param += " -level " + level;`
	`2359`	`}`
	`2360`	`}`
	`2361`
0	`2362`	`if (string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase))`
	`2363`	`{`
0	`2364`	`param += " -x264opts:0 subme=0:me_range=16:rc_lookahead=10:me=hex:open_gop=0";`
	`2365`	`}`
	`2366`
0	`2367`	`if (string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase))`
	`2368`	`{`
	`2369`	`// libx265 only accept level option in -x265-params.`
	`2370`	`// level option may cause libx265 to fail.`
	`2371`	`// libx265 cannot adjust the given level, just throw an error.`
0	`2372`	`param += " -x265-params:0 no-scenecut=1:no-open-gop=1:no-info=1";`
	`2373`
0	`2374`	`if (encodingOptions.EncoderPreset < EncoderPreset.ultrafast)`
	`2375`	`{`
	`2376`	`// The following params are slower than the ultrafast preset, don't use when ultrafast is selected.`
0	`2377`	`param += ":subme=3:merange=25:rc-lookahead=10:me=star:ctu=32:max-tu-size=32:min-cu-size=16:rskip=2:r`
	`2378`	`}`
	`2379`	`}`
	`2380`
0	`2381`	`if (string.Equals(videoEncoder, "libsvtav1", StringComparison.OrdinalIgnoreCase)`
0	`2382`	`&& _mediaEncoder.EncoderVersion >= _minFFmpegSvtAv1Params)`
	`2383`	`{`
0	`2384`	`param += " -svtav1-params:0 rc=1:tune=0:film-grain=0:enable-overlays=1:enable-tf=0";`
	`2385`	`}`
	`2386`
	`2387`	`/* Access unit too large: 8192 < 20880 error */`
0	`2388`	`if ((string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase) \|\|`
0	`2389`	`string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)) &&`
0	`2390`	`_mediaEncoder.EncoderVersion >= _minFFmpegVaapiH26xEncA53CcSei)`
	`2391`	`{`
0	`2392`	`param += " -sei -a53_cc";`
	`2393`	`}`
	`2394`
0	`2395`	`return param;`
	`2396`	`}`
	`2397`
	`2398`	`public bool CanStreamCopyVideo(EncodingJobInfo state, MediaStream videoStream)`
	`2399`	`{`
0	`2400`	`var request = state.BaseRequest;`
	`2401`
0	`2402`	`if (!request.AllowVideoStreamCopy)`
	`2403`	`{`
0	`2404`	`return false;`
	`2405`	`}`
	`2406`
0	`2407`	`if (videoStream.IsInterlaced`
0	`2408`	`&& state.DeInterlace(videoStream.Codec, false))`
	`2409`	`{`
0	`2410`	`return false;`
	`2411`	`}`
	`2412`
0	`2413`	`if (videoStream.IsAnamorphic ?? false)`
	`2414`	`{`
0	`2415`	`if (request.RequireNonAnamorphic)`
	`2416`	`{`
0	`2417`	`return false;`
	`2418`	`}`
	`2419`	`}`
	`2420`
	`2421`	`// Can't stream copy if we're burning in subtitles`
0	`2422`	`if (request.SubtitleStreamIndex.HasValue`
0	`2423`	`&& request.SubtitleStreamIndex.Value >= 0`
0	`2424`	`&& state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)`
	`2425`	`{`
0	`2426`	`return false;`
	`2427`	`}`
	`2428`
0	`2429`	`if (string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`2430`	`&& videoStream.IsAVC.HasValue`
0	`2431`	`&& !videoStream.IsAVC.Value`
0	`2432`	`&& request.RequireAvc)`
	`2433`	`{`
0	`2434`	`return false;`
	`2435`	`}`
	`2436`
	`2437`	`// Source and target codecs must match`
0	`2438`	`if (string.IsNullOrEmpty(videoStream.Codec)`
0	`2439`	`\|\| (state.SupportedVideoCodecs.Length != 0`
0	`2440`	`&& !state.SupportedVideoCodecs.Contains(videoStream.Codec, StringComparison.OrdinalIgnoreCase)))`
	`2441`	`{`
0	`2442`	`return false;`
	`2443`	`}`
	`2444`
0	`2445`	`var requestedProfiles = state.GetRequestedProfiles(videoStream.Codec);`
	`2446`
	`2447`	`// If client is requesting a specific video profile, it must match the source`
0	`2448`	`if (requestedProfiles.Length > 0)`
	`2449`	`{`
0	`2450`	`if (string.IsNullOrEmpty(videoStream.Profile))`
	`2451`	`{`
	`2452`	`// return false;`
	`2453`	`}`
	`2454`
0	`2455`	`var requestedProfile = requestedProfiles[0];`
	`2456`	`// strip spaces because they may be stripped out on the query string as well`
0	`2457`	`if (!string.IsNullOrEmpty(videoStream.Profile)`
0	`2458`	`&& !requestedProfiles.Contains(videoStream.Profile.Replace(" ", string.Empty, StringComparison.Ordin`
	`2459`	`{`
0	`2460`	`var currentScore = GetVideoProfileScore(videoStream.Codec, videoStream.Profile);`
0	`2461`	`var requestedScore = GetVideoProfileScore(videoStream.Codec, requestedProfile);`
	`2462`
0	`2463`	`if (currentScore == -1 \|\| currentScore > requestedScore)`
	`2464`	`{`
0	`2465`	`return false;`
	`2466`	`}`
	`2467`	`}`
	`2468`	`}`
	`2469`
0	`2470`	`var requestedRangeTypes = state.GetRequestedRangeTypes(videoStream.Codec);`
0	`2471`	`if (requestedRangeTypes.Length > 0)`
	`2472`	`{`
0	`2473`	`if (videoStream.VideoRangeType == VideoRangeType.Unknown)`
	`2474`	`{`
0	`2475`	`return false;`
	`2476`	`}`
	`2477`
	`2478`	`// DOVIWithHDR10 should be compatible with HDR10 supporting players. Same goes with HLG and of course SD`
0	`2479`	`var requestHasHDR10 = requestedRangeTypes.Contains(VideoRangeType.HDR10.ToString(), StringComparison.Ord`
0	`2480`	`var requestHasHLG = requestedRangeTypes.Contains(VideoRangeType.HLG.ToString(), StringComparison.Ordinal`
0	`2481`	`var requestHasSDR = requestedRangeTypes.Contains(VideoRangeType.SDR.ToString(), StringComparison.Ordinal`
0	`2482`	`var requestHasDOVI = requestedRangeTypes.Contains(VideoRangeType.DOVI.ToString(), StringComparison.Ordin`
	`2483`
	`2484`	`// If SDR is the only supported range, we should not copy any of the HDR streams.`
	`2485`	`// All the following copy check assumes at least one HDR format is supported.`
0	`2486`	`if (requestedRangeTypes.Length == 1 && requestHasSDR && videoStream.VideoRangeType != VideoRangeType.SDR`
	`2487`	`{`
0	`2488`	`return false;`
	`2489`	`}`
	`2490`
	`2491`	`// If the client does not support DOVI and the video stream is DOVI without fallback, we should not copy`
0	`2492`	`if (!requestHasDOVI && videoStream.VideoRangeType == VideoRangeType.DOVI)`
	`2493`	`{`
0	`2494`	`return false;`
	`2495`	`}`
	`2496`
0	`2497`	`if (!requestedRangeTypes.Contains(videoStream.VideoRangeType.ToString(), StringComparison.OrdinalIgnoreC`
0	`2498`	`&& !((requestHasHDR10 && videoStream.VideoRangeType == VideoRangeType.DOVIWithHDR10)`
0	`2499`	`\|\| (requestHasHLG && videoStream.VideoRangeType == VideoRangeType.DOVIWithHLG)`
0	`2500`	`\|\| (requestHasSDR && videoStream.VideoRangeType == VideoRangeType.DOVIWithSDR)`
0	`2501`	`\|\| (requestHasHDR10 && videoStream.VideoRangeType == VideoRangeType.HDR10Plus)))`
	`2502`	`{`
	`2503`	`// If the video stream is in HDR10+ or a static HDR format, don't allow copy if the client does not`
0	`2504`	`if (videoStream.VideoRangeType is VideoRangeType.HDR10Plus or VideoRangeType.HDR10 or VideoRangeType`
	`2505`	`{`
0	`2506`	`return false;`
	`2507`	`}`
	`2508`
	`2509`	`// Check complicated cases where we need to remove dynamic metadata`
	`2510`	`// Conservatively refuse to copy if the encoder can't remove dynamic metadata,`
	`2511`	`// but a removal is required for compatability reasons.`
0	`2512`	`var dynamicHdrMetadataRemovalPlan = ShouldRemoveDynamicHdrMetadata(state);`
0	`2513`	`if (!CanEncoderRemoveDynamicHdrMetadata(dynamicHdrMetadataRemovalPlan, videoStream))`
	`2514`	`{`
0	`2515`	`return false;`
	`2516`	`}`
	`2517`	`}`
	`2518`	`}`
	`2519`
0	`2520`	`var requestedRotations = state.GetRequestedRotations(videoStream.Codec);`
0	`2521`	`if (requestedRotations.Length > 0)`
	`2522`	`{`
0	`2523`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`2524`	`if (rotation != 0`
0	`2525`	`&& !requestedRotations.Contains(rotation.ToString(CultureInfo.InvariantCulture), StringComparison.Or`
	`2526`	`{`
0	`2527`	`return false;`
	`2528`	`}`
	`2529`	`}`
	`2530`
	`2531`	`// Video width must fall within requested value`
0	`2532`	`if (request.MaxWidth.HasValue`
0	`2533`	`&& (!videoStream.Width.HasValue \|\| videoStream.Width.Value > request.MaxWidth.Value))`
	`2534`	`{`
0	`2535`	`return false;`
	`2536`	`}`
	`2537`
	`2538`	`// Video height must fall within requested value`
0	`2539`	`if (request.MaxHeight.HasValue`
0	`2540`	`&& (!videoStream.Height.HasValue \|\| videoStream.Height.Value > request.MaxHeight.Value))`
	`2541`	`{`
0	`2542`	`return false;`
	`2543`	`}`
	`2544`
	`2545`	`// Video framerate must fall within requested value`
0	`2546`	`var requestedFramerate = request.MaxFramerate ?? request.Framerate;`
0	`2547`	`if (requestedFramerate.HasValue)`
	`2548`	`{`
0	`2549`	`var videoFrameRate = videoStream.ReferenceFrameRate;`
	`2550`
	`2551`	`// Add a little tolerance to the framerate check because some videos might record a framerate`
	`2552`	`// that is slightly greater than the intended framerate, but the device can still play it correctly.`
	`2553`	`// 0.05 fps tolerance should be safe enough.`
0	`2554`	`if (!videoFrameRate.HasValue \|\| videoFrameRate.Value > requestedFramerate.Value + 0.05f)`
	`2555`	`{`
0	`2556`	`return false;`
	`2557`	`}`
	`2558`	`}`
	`2559`
	`2560`	`// Video bitrate must fall within requested value`
0	`2561`	`if (request.VideoBitRate.HasValue`
0	`2562`	`&& (!videoStream.BitRate.HasValue \|\| videoStream.BitRate.Value > request.VideoBitRate.Value))`
	`2563`	`{`
	`2564`	`// For LiveTV that has no bitrate, let's try copy if other conditions are met`
0	`2565`	`if (string.IsNullOrWhiteSpace(request.LiveStreamId) \|\| videoStream.BitRate.HasValue)`
	`2566`	`{`
0	`2567`	`return false;`
	`2568`	`}`
	`2569`	`}`
	`2570`
0	`2571`	`var maxBitDepth = state.GetRequestedVideoBitDepth(videoStream.Codec);`
0	`2572`	`if (maxBitDepth.HasValue)`
	`2573`	`{`
0	`2574`	`if (videoStream.BitDepth.HasValue && videoStream.BitDepth.Value > maxBitDepth.Value)`
	`2575`	`{`
0	`2576`	`return false;`
	`2577`	`}`
	`2578`	`}`
	`2579`
0	`2580`	`var maxRefFrames = state.GetRequestedMaxRefFrames(videoStream.Codec);`
0	`2581`	`if (maxRefFrames.HasValue`
0	`2582`	`&& videoStream.RefFrames.HasValue && videoStream.RefFrames.Value > maxRefFrames.Value)`
	`2583`	`{`
0	`2584`	`return false;`
	`2585`	`}`
	`2586`
	`2587`	`// If a specific level was requested, the source must match or be less than`
0	`2588`	`var level = state.GetRequestedLevel(videoStream.Codec);`
0	`2589`	`if (double.TryParse(level, CultureInfo.InvariantCulture, out var requestLevel))`
	`2590`	`{`
0	`2591`	`if (!videoStream.Level.HasValue)`
	`2592`	`{`
	`2593`	`// return false;`
	`2594`	`}`
	`2595`
0	`2596`	`if (videoStream.Level.HasValue && videoStream.Level.Value > requestLevel)`
	`2597`	`{`
0	`2598`	`return false;`
	`2599`	`}`
	`2600`	`}`
	`2601`
0	`2602`	`if (string.Equals(state.InputContainer, "avi", StringComparison.OrdinalIgnoreCase)`
0	`2603`	`&& string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase)`
0	`2604`	`&& !(videoStream.IsAVC ?? false))`
	`2605`	`{`
	`2606`	`// see Coach S01E01 - Kelly and the Professor(0).avi`
0	`2607`	`return false;`
	`2608`	`}`
	`2609`
0	`2610`	`return true;`
	`2611`	`}`
	`2612`
	`2613`	`public bool CanStreamCopyAudio(EncodingJobInfo state, MediaStream audioStream, IEnumerable<string> supportedAudi`
	`2614`	`{`
0	`2615`	`var request = state.BaseRequest;`
	`2616`
0	`2617`	`if (!request.AllowAudioStreamCopy)`
	`2618`	`{`
0	`2619`	`return false;`
	`2620`	`}`
	`2621`
0	`2622`	`var maxBitDepth = state.GetRequestedAudioBitDepth(audioStream.Codec);`
0	`2623`	`if (maxBitDepth.HasValue`
0	`2624`	`&& audioStream.BitDepth.HasValue`
0	`2625`	`&& audioStream.BitDepth.Value > maxBitDepth.Value)`
	`2626`	`{`
0	`2627`	`return false;`
	`2628`	`}`
	`2629`
	`2630`	`// Source and target codecs must match`
0	`2631`	`if (string.IsNullOrEmpty(audioStream.Codec)`
0	`2632`	`\|\| !supportedAudioCodecs.Contains(audioStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`2633`	`{`
0	`2634`	`return false;`
	`2635`	`}`
	`2636`
	`2637`	`// Channels must fall within requested value`
0	`2638`	`var channels = state.GetRequestedAudioChannels(audioStream.Codec);`
0	`2639`	`if (channels.HasValue)`
	`2640`	`{`
0	`2641`	`if (!audioStream.Channels.HasValue \|\| audioStream.Channels.Value <= 0)`
	`2642`	`{`
0	`2643`	`return false;`
	`2644`	`}`
	`2645`
0	`2646`	`if (audioStream.Channels.Value > channels.Value)`
	`2647`	`{`
0	`2648`	`return false;`
	`2649`	`}`
	`2650`	`}`
	`2651`
	`2652`	`// Sample rate must fall within requested value`
0	`2653`	`if (request.AudioSampleRate.HasValue)`
	`2654`	`{`
0	`2655`	`if (!audioStream.SampleRate.HasValue \|\| audioStream.SampleRate.Value <= 0)`
	`2656`	`{`
0	`2657`	`return false;`
	`2658`	`}`
	`2659`
0	`2660`	`if (audioStream.SampleRate.Value > request.AudioSampleRate.Value)`
	`2661`	`{`
0	`2662`	`return false;`
	`2663`	`}`
	`2664`	`}`
	`2665`
	`2666`	`// Audio bitrate must fall within requested value`
0	`2667`	`if (request.AudioBitRate.HasValue`
0	`2668`	`&& audioStream.BitRate.HasValue`
0	`2669`	`&& audioStream.BitRate.Value > request.AudioBitRate.Value)`
	`2670`	`{`
0	`2671`	`return false;`
	`2672`	`}`
	`2673`
0	`2674`	`return request.EnableAutoStreamCopy;`
	`2675`	`}`
	`2676`
	`2677`	`public int GetVideoBitrateParamValue(BaseEncodingJobOptions request, MediaStream videoStream, string outputVideo`
	`2678`	`{`
0	`2679`	`var bitrate = request.VideoBitRate;`
	`2680`
0	`2681`	`if (videoStream is not null)`
	`2682`	`{`
0	`2683`	`var isUpscaling = request.Height.HasValue`
0	`2684`	`&& videoStream.Height.HasValue`
0	`2685`	`&& request.Height.Value > videoStream.Height.Value`
0	`2686`	`&& request.Width.HasValue`
0	`2687`	`&& videoStream.Width.HasValue`
0	`2688`	`&& request.Width.Value > videoStream.Width.Value;`
	`2689`
	`2690`	`// Don't allow bitrate increases unless upscaling`
0	`2691`	`if (!isUpscaling && bitrate.HasValue && videoStream.BitRate.HasValue)`
	`2692`	`{`
0	`2693`	`bitrate = GetMinBitrate(videoStream.BitRate.Value, bitrate.Value);`
	`2694`	`}`
	`2695`
0	`2696`	`if (bitrate.HasValue)`
	`2697`	`{`
0	`2698`	`var inputVideoCodec = videoStream.Codec;`
0	`2699`	`bitrate = ScaleBitrate(bitrate.Value, inputVideoCodec, outputVideoCodec);`
	`2700`
	`2701`	`// If a max bitrate was requested, don't let the scaled bitrate exceed it`
0	`2702`	`if (request.VideoBitRate.HasValue)`
	`2703`	`{`
0	`2704`	`bitrate = Math.Min(bitrate.Value, request.VideoBitRate.Value);`
	`2705`	`}`
	`2706`	`}`
	`2707`	`}`
	`2708`
	`2709`	`// Cap the max target bitrate to 400 Mbps.`
	`2710`	`// No consumer or professional hardware transcode target exceeds this value`
	`2711`	`// (Intel QSV tops out at ~300 Mbps for H.264; HEVC High Tier Level 5.x is ~240 Mbps).`
	`2712`	`// Without this cap, plugin-provided MPEG-TS streams with no usable bitrate metadata`
	`2713`	`// can produce unreasonably large -bufsize/-maxrate values for the encoder.`
	`2714`	`// Note: the existing FallbackMaxStreamingBitrate mechanism (default 30 Mbps) only`
	`2715`	`// applies when a LiveStreamId is set (M3U/HDHR sources). Plugin streams and other`
	`2716`	`// sources that bypass the LiveTV pipeline are not covered by it.`
	`2717`	`const int MaxSaneBitrate = 400_000_000; // 400 Mbps`
0	`2718`	`return Math.Min(bitrate ?? 0, MaxSaneBitrate);`
	`2719`	`}`
	`2720`
	`2721`	`private int GetMinBitrate(int sourceBitrate, int requestedBitrate)`
	`2722`	`{`
	`2723`	`// these values were chosen from testing to improve low bitrate streams`
0	`2724`	`if (sourceBitrate <= 2000000)`
	`2725`	`{`
0	`2726`	`sourceBitrate = Convert.ToInt32(sourceBitrate * 2.5);`
	`2727`	`}`
0	`2728`	`else if (sourceBitrate <= 3000000)`
	`2729`	`{`
0	`2730`	`sourceBitrate *= 2;`
	`2731`	`}`
	`2732`
0	`2733`	`var bitrate = Math.Min(sourceBitrate, requestedBitrate);`
	`2734`
0	`2735`	`return bitrate;`
	`2736`	`}`
	`2737`
	`2738`	`private static double GetVideoBitrateScaleFactor(string codec)`
	`2739`	`{`
	`2740`	`// hevc & vp9 - 40% more efficient than h.264`
0	`2741`	`if (string.Equals(codec, "h265", StringComparison.OrdinalIgnoreCase)`
0	`2742`	`\|\| string.Equals(codec, "hevc", StringComparison.OrdinalIgnoreCase)`
0	`2743`	`\|\| string.Equals(codec, "vp9", StringComparison.OrdinalIgnoreCase))`
	`2744`	`{`
0	`2745`	`return .6;`
	`2746`	`}`
	`2747`
	`2748`	`// av1 - 50% more efficient than h.264`
0	`2749`	`if (string.Equals(codec, "av1", StringComparison.OrdinalIgnoreCase))`
	`2750`	`{`
0	`2751`	`return .5;`
	`2752`	`}`
	`2753`
0	`2754`	`return 1;`
	`2755`	`}`
	`2756`
	`2757`	`public static int ScaleBitrate(int bitrate, string inputVideoCodec, string outputVideoCodec)`
	`2758`	`{`
0	`2759`	`var inputScaleFactor = GetVideoBitrateScaleFactor(inputVideoCodec);`
0	`2760`	`var outputScaleFactor = GetVideoBitrateScaleFactor(outputVideoCodec);`
	`2761`
	`2762`	`// Don't scale the real bitrate lower than the requested bitrate`
0	`2763`	`var scaleFactor = Math.Max(outputScaleFactor / inputScaleFactor, 1);`
	`2764`
0	`2765`	`if (bitrate <= 500000)`
	`2766`	`{`
0	`2767`	`scaleFactor = Math.Max(scaleFactor, 4);`
	`2768`	`}`
0	`2769`	`else if (bitrate <= 1000000)`
	`2770`	`{`
0	`2771`	`scaleFactor = Math.Max(scaleFactor, 3);`
	`2772`	`}`
0	`2773`	`else if (bitrate <= 2000000)`
	`2774`	`{`
0	`2775`	`scaleFactor = Math.Max(scaleFactor, 2.5);`
	`2776`	`}`
0	`2777`	`else if (bitrate <= 3000000)`
	`2778`	`{`
0	`2779`	`scaleFactor = Math.Max(scaleFactor, 2);`
	`2780`	`}`
0	`2781`	`else if (bitrate >= 30000000)`
	`2782`	`{`
	`2783`	`// Don't scale beyond 30Mbps, it is hardly visually noticeable for most codecs with our prefer speed enc`
	`2784`	`// and will cause extremely high bitrate to be used for av1->h264 transcoding that will overload clients`
0	`2785`	`scaleFactor = 1;`
	`2786`	`}`
	`2787`
0	`2788`	`return Convert.ToInt32(scaleFactor * bitrate);`
	`2789`	`}`
	`2790`
	`2791`	`public int? GetAudioBitrateParam(BaseEncodingJobOptions request, MediaStream audioStream, int? outputAudioChanne`
	`2792`	`{`
0	`2793`	`return GetAudioBitrateParam(request.AudioBitRate, request.AudioCodec, audioStream, outputAudioChannels);`
	`2794`	`}`
	`2795`
	`2796`	`public int? GetAudioBitrateParam(int? audioBitRate, string audioCodec, MediaStream audioStream, int? outputAudio`
	`2797`	`{`
0	`2798`	`if (audioStream is null)`
	`2799`	`{`
0	`2800`	`return null;`
	`2801`	`}`
	`2802`
0	`2803`	`var inputChannels = audioStream.Channels ?? 0;`
0	`2804`	`var outputChannels = outputAudioChannels ?? 0;`
0	`2805`	`var bitrate = audioBitRate ?? int.MaxValue;`
	`2806`
0	`2807`	`if (string.IsNullOrEmpty(audioCodec)`
0	`2808`	`\|\| string.Equals(audioCodec, "aac", StringComparison.OrdinalIgnoreCase)`
0	`2809`	`\|\| string.Equals(audioCodec, "mp3", StringComparison.OrdinalIgnoreCase)`
0	`2810`	`\|\| string.Equals(audioCodec, "opus", StringComparison.OrdinalIgnoreCase)`
0	`2811`	`\|\| string.Equals(audioCodec, "vorbis", StringComparison.OrdinalIgnoreCase)`
0	`2812`	`\|\| string.Equals(audioCodec, "ac3", StringComparison.OrdinalIgnoreCase)`
0	`2813`	`\|\| string.Equals(audioCodec, "eac3", StringComparison.OrdinalIgnoreCase))`
	`2814`	`{`
	`2815`	`#pragma warning disable SA1008`
0	`2816`	`return (inputChannels, outputChannels) switch`
0	`2817`	`{`
0	`2818`	`( >= 6, >= 6 or 0) => Math.Min(640000, bitrate),`
0	`2819`	`( > 0, > 0) => Math.Min(outputChannels * 128000, bitrate),`
0	`2820`	`( > 0, _) => Math.Min(inputChannels * 128000, bitrate),`
0	`2821`	`(_, _) => Math.Min(384000, bitrate)`
0	`2822`	`};`
	`2823`	`#pragma warning restore SA1008`
	`2824`	`}`
	`2825`
0	`2826`	`if (string.Equals(audioCodec, "dts", StringComparison.OrdinalIgnoreCase)`
0	`2827`	`\|\| string.Equals(audioCodec, "dca", StringComparison.OrdinalIgnoreCase))`
	`2828`	`{`
	`2829`	`#pragma warning disable SA1008`
0	`2830`	`return (inputChannels, outputChannels) switch`
0	`2831`	`{`
0	`2832`	`( >= 6, >= 6 or 0) => Math.Min(768000, bitrate),`
0	`2833`	`( > 0, > 0) => Math.Min(outputChannels * 136000, bitrate),`
0	`2834`	`( > 0, _) => Math.Min(inputChannels * 136000, bitrate),`
0	`2835`	`(_, _) => Math.Min(672000, bitrate)`
0	`2836`	`};`
	`2837`	`#pragma warning restore SA1008`
	`2838`	`}`
	`2839`
	`2840`	`// Empty bitrate area is not allow on iOS`
	`2841`	`// Default audio bitrate to 128K per channel if we don't have codec specific defaults`
	`2842`	`// https://ffmpeg.org/ffmpeg-codecs.html#toc-Codec-Options`
0	`2843`	`return 128000 * (outputAudioChannels ?? audioStream.Channels ?? 2);`
	`2844`	`}`
	`2845`
	`2846`	`public string GetAudioVbrModeParam(string encoder, int bitrate, int channels)`
	`2847`	`{`
0	`2848`	`var bitratePerChannel = bitrate / Math.Max(channels, 1);`
0	`2849`	`if (string.Equals(encoder, "libfdk_aac", StringComparison.OrdinalIgnoreCase))`
	`2850`	`{`
0	`2851`	`return " -vbr:a " + bitratePerChannel switch`
0	`2852`	`{`
0	`2853`	`< 32000 => "1",`
0	`2854`	`< 48000 => "2",`
0	`2855`	`< 64000 => "3",`
0	`2856`	`< 96000 => "4",`
0	`2857`	`_ => "5"`
0	`2858`	`};`
	`2859`	`}`
	`2860`
0	`2861`	`if (string.Equals(encoder, "libmp3lame", StringComparison.OrdinalIgnoreCase))`
	`2862`	`{`
	`2863`	`// lame's VBR is only good for a certain bitrate range`
	`2864`	`// For very low and very high bitrate, use abr mode`
0	`2865`	`if (bitratePerChannel is < 122500 and > 48000)`
	`2866`	`{`
0	`2867`	`return " -qscale:a " + bitratePerChannel switch`
0	`2868`	`{`
0	`2869`	`< 64000 => "6",`
0	`2870`	`< 88000 => "4",`
0	`2871`	`< 112000 => "2",`
0	`2872`	`_ => "0"`
0	`2873`	`};`
	`2874`	`}`
	`2875`
0	`2876`	`return " -abr:a 1" + " -b:a " + bitrate;`
	`2877`	`}`
	`2878`
0	`2879`	`if (string.Equals(encoder, "aac_at", StringComparison.OrdinalIgnoreCase))`
	`2880`	`{`
	`2881`	`// aac_at's CVBR mode`
0	`2882`	`return " -aac_at_mode:a 2" + " -b:a " + bitrate;`
	`2883`	`}`
	`2884`
0	`2885`	`if (string.Equals(encoder, "libvorbis", StringComparison.OrdinalIgnoreCase))`
	`2886`	`{`
0	`2887`	`return " -qscale:a " + bitratePerChannel switch`
0	`2888`	`{`
0	`2889`	`< 40000 => "0",`
0	`2890`	`< 56000 => "2",`
0	`2891`	`< 80000 => "4",`
0	`2892`	`< 112000 => "6",`
0	`2893`	`_ => "8"`
0	`2894`	`};`
	`2895`	`}`
	`2896`
0	`2897`	`return null;`
	`2898`	`}`
	`2899`
	`2900`	`public string GetAudioFilterParam(EncodingJobInfo state, EncodingOptions encodingOptions)`
	`2901`	`{`
0	`2902`	`var channels = state.OutputAudioChannels;`
	`2903`
0	`2904`	`var filters = new List<string>();`
	`2905`
0	`2906`	`if (channels is 2 && state.AudioStream?.Channels is > 2)`
	`2907`	`{`
0	`2908`	`var hasDownMixFilter = DownMixAlgorithmsHelper.AlgorithmFilterStrings.TryGetValue((encodingOptions.DownM`
0	`2909`	`if (hasDownMixFilter)`
	`2910`	`{`
0	`2911`	`filters.Add(downMixFilterString);`
	`2912`	`}`
	`2913`
0	`2914`	`if (!encodingOptions.DownMixAudioBoost.Equals(1))`
	`2915`	`{`
0	`2916`	`filters.Add("volume=" + encodingOptions.DownMixAudioBoost.ToString(CultureInfo.InvariantCulture));`
	`2917`	`}`
	`2918`	`}`
	`2919`
0	`2920`	`var isCopyingTimestamps = state.CopyTimestamps \|\| state.TranscodingType != TranscodingJobType.Progressive;`
0	`2921`	`if (state.SubtitleStream is not null && state.SubtitleStream.IsTextSubtitleStream && ShouldEncodeSubtitle(st`
	`2922`	`{`
0	`2923`	`var seconds = TimeSpan.FromTicks(state.StartTimeTicks ?? 0).TotalSeconds;`
	`2924`
0	`2925`	`filters.Add(`
0	`2926`	`string.Format(`
0	`2927`	`CultureInfo.InvariantCulture,`
0	`2928`	`"asetpts=PTS-{0}/TB",`
0	`2929`	`Math.Round(seconds)));`
	`2930`	`}`
	`2931`
0	`2932`	`if (filters.Count > 0)`
	`2933`	`{`
0	`2934`	`return " -af \"" + string.Join(',', filters) + "\"";`
	`2935`	`}`
	`2936`
0	`2937`	`return string.Empty;`
	`2938`	`}`
	`2939`
	`2940`	`/// <summary>`
	`2941`	`/// Gets the number of audio channels to specify on the command line.`
	`2942`	`/// </summary>`
	`2943`	`/// <param name="state">The state.</param>`
	`2944`	`/// <param name="audioStream">The audio stream.</param>`
	`2945`	`/// <param name="outputAudioCodec">The output audio codec.</param>`
	`2946`	`/// <returns>System.Nullable{System.Int32}.</returns>`
	`2947`	`public int? GetNumAudioChannelsParam(EncodingJobInfo state, MediaStream audioStream, string outputAudioCodec)`
	`2948`	`{`
0	`2949`	`if (audioStream is null)`
	`2950`	`{`
0	`2951`	`return null;`
	`2952`	`}`
	`2953`
0	`2954`	`var request = state.BaseRequest;`
	`2955`
0	`2956`	`var codec = outputAudioCodec ?? string.Empty;`
	`2957`
0	`2958`	`int? resultChannels = state.GetRequestedAudioChannels(codec);`
	`2959`
0	`2960`	`var inputChannels = audioStream.Channels;`
	`2961`
0	`2962`	`if (inputChannels > 0)`
	`2963`	`{`
0	`2964`	`resultChannels = inputChannels < resultChannels ? inputChannels : resultChannels ?? inputChannels;`
	`2965`	`}`
	`2966`
0	`2967`	`var isTranscodingAudio = !IsCopyCodec(codec);`
	`2968`
0	`2969`	`if (isTranscodingAudio)`
	`2970`	`{`
0	`2971`	`var audioEncoder = GetAudioEncoder(state);`
0	`2972`	`if (!_audioTranscodeChannelLookup.TryGetValue(audioEncoder, out var transcoderChannelLimit))`
	`2973`	`{`
	`2974`	`// Set default max transcoding channels to 8 to prevent encoding errors due to asking for too many c`
0	`2975`	`transcoderChannelLimit = 8;`
	`2976`	`}`
	`2977`
	`2978`	`// Set resultChannels to minimum between resultChannels, TranscodingMaxAudioChannels, transcoderChannelL`
0	`2979`	`resultChannels = transcoderChannelLimit < resultChannels ? transcoderChannelLimit : resultChannels ?? tr`
	`2980`
0	`2981`	`if (request.TranscodingMaxAudioChannels < resultChannels)`
	`2982`	`{`
0	`2983`	`resultChannels = request.TranscodingMaxAudioChannels;`
	`2984`	`}`
	`2985`
	`2986`	`// Avoid transcoding to audio channels other than 1ch, 2ch, 6ch (5.1 layout) and 8ch (7.1 layout).`
	`2987`	`// https://developer.apple.com/documentation/http_live_streaming/hls_authoring_specification_for_apple_d`
0	`2988`	`if (state.TranscodingType != TranscodingJobType.Progressive`
0	`2989`	`&& ((resultChannels > 2 && resultChannels < 6) \|\| resultChannels == 7))`
	`2990`	`{`
	`2991`	`// We can let FFMpeg supply an extra LFE channel for 5ch and 7ch to make them 5.1 and 7.1`
0	`2992`	`if (resultChannels == 5)`
	`2993`	`{`
0	`2994`	`resultChannels = 6;`
	`2995`	`}`
0	`2996`	`else if (resultChannels == 7)`
	`2997`	`{`
0	`2998`	`resultChannels = 8;`
	`2999`	`}`
	`3000`	`else`
	`3001`	`{`
	`3002`	`// For other weird layout, just downmix to stereo for compatibility`
0	`3003`	`resultChannels = 2;`
	`3004`	`}`
	`3005`	`}`
	`3006`	`}`
	`3007`
0	`3008`	`return resultChannels;`
	`3009`	`}`
	`3010`
	`3011`	`/// <summary>`
	`3012`	`/// Enforces the resolution limit.`
	`3013`	`/// </summary>`
	`3014`	`/// <param name="state">The state.</param>`
	`3015`	`public void EnforceResolutionLimit(EncodingJobInfo state)`
	`3016`	`{`
0	`3017`	`var videoRequest = state.BaseRequest;`
	`3018`
	`3019`	`// Switch the incoming params to be ceilings rather than fixed values`
0	`3020`	`videoRequest.MaxWidth = videoRequest.MaxWidth ?? videoRequest.Width;`
0	`3021`	`videoRequest.MaxHeight = videoRequest.MaxHeight ?? videoRequest.Height;`
	`3022`
0	`3023`	`videoRequest.Width = null;`
0	`3024`	`videoRequest.Height = null;`
0	`3025`	`}`
	`3026`
	`3027`	`/// <summary>`
	`3028`	`/// Gets the fast seek command line parameter.`
	`3029`	`/// </summary>`
	`3030`	`/// <param name="state">The state.</param>`
	`3031`	`/// <param name="options">The options.</param>`
	`3032`	`/// <param name="segmentContainer">Segment Container.</param>`
	`3033`	`/// <returns>System.String.</returns>`
	`3034`	`/// <value>The fast seek command line parameter.</value>`
	`3035`	`public string GetFastSeekCommandLineParameter(EncodingJobInfo state, EncodingOptions options, string segmentCont`
	`3036`	`{`
4	`3037`	`var time = state.BaseRequest.StartTimeTicks ?? 0;`
4	`3038`	`var maxTime = state.RunTimeTicks ?? 0;`
4	`3039`	`var seekParam = string.Empty;`
	`3040`
4	`3041`	`if (time > 0)`
	`3042`	`{`
	`3043`	`// For direct streaming/remuxing, HLS segments start at keyframes.`
	`3044`	`// However, ffmpeg will seek to previous keyframe when the exact frame time is the input`
	`3045`	`// Workaround this by adding 0.5s offset to the seeking time to get the exact keyframe on most videos.`
	`3046`	`// This will help subtitle syncing.`
0	`3047`	`var isHlsRemuxing = state.IsVideoRequest && state.TranscodingType is TranscodingJobType.Hls && IsCopyCod`
0	`3048`	`var seekTick = isHlsRemuxing ? time + 5000000L : time;`
	`3049`
	`3050`	`// Seeking beyond EOF makes no sense in transcoding. Clamp the seekTick value to`
	`3051`	`// [0, RuntimeTicks - 5.0s], so that the muxer gets packets and avoid error codes.`
0	`3052`	`if (maxTime > 0)`
	`3053`	`{`
0	`3054`	`seekTick = Math.Clamp(seekTick, 0, Math.Max(maxTime - 50000000L, 0));`
	`3055`	`}`
	`3056`
0	`3057`	`seekParam += string.Format(CultureInfo.InvariantCulture, "-ss {0}", _mediaEncoder.GetTimeParameter(seekT`
	`3058`	`}`
	`3059`
4	`3060`	`return seekParam;`
	`3061`	`}`
	`3062`
	`3063`	`/// <summary>`
	`3064`	`/// Gets the map args.`
	`3065`	`/// </summary>`
	`3066`	`/// <param name="state">The state.</param>`
	`3067`	`/// <returns>System.String.</returns>`
	`3068`	`public string GetMapArgs(EncodingJobInfo state)`
	`3069`	`{`
	`3070`	`// If we don't have known media info`
	`3071`	`// If input is video, use -sn to drop subtitles`
	`3072`	`// Otherwise just return empty`
7	`3073`	`if (state.VideoStream is null && state.AudioStream is null)`
	`3074`	`{`
0	`3075`	`return state.IsInputVideo ? "-sn" : string.Empty;`
	`3076`	`}`
	`3077`
	`3078`	`// We have media info, but we don't know the stream index`
7	`3079`	`if (state.VideoStream is not null && state.VideoStream.Index == -1)`
	`3080`	`{`
0	`3081`	`return "-sn";`
	`3082`	`}`
	`3083`
	`3084`	`// We have media info, but we don't know the stream index`
7	`3085`	`if (state.AudioStream is not null && state.AudioStream.Index == -1)`
	`3086`	`{`
0	`3087`	`return state.IsInputVideo ? "-sn" : string.Empty;`
	`3088`	`}`
	`3089`
7	`3090`	`var args = string.Empty;`
	`3091`
7	`3092`	`if (state.VideoStream is not null)`
	`3093`	`{`
7	`3094`	`int videoStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.VideoStream);`
	`3095`
7	`3096`	`args += string.Format(`
7	`3097`	`CultureInfo.InvariantCulture,`
7	`3098`	`"-map 0:{0}",`
7	`3099`	`videoStreamIndex);`
	`3100`	`}`
	`3101`	`else`
	`3102`	`{`
	`3103`	`// No known video stream`
0	`3104`	`args += "-vn";`
	`3105`	`}`
	`3106`
7	`3107`	`if (state.AudioStream is not null)`
	`3108`	`{`
7	`3109`	`int audioStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.AudioStream);`
7	`3110`	`if (state.AudioStream.IsExternal)`
	`3111`	`{`
0	`3112`	`bool hasExternalSubAsInput = NeedsExternalSubtitleMuxing(state);`
0	`3113`	`int externalAudioMapIndex = hasExternalSubAsInput ? 2 : 1;`
	`3114`
0	`3115`	`args += string.Format(`
0	`3116`	`CultureInfo.InvariantCulture,`
0	`3117`	`" -map {0}:{1}",`
0	`3118`	`externalAudioMapIndex,`
0	`3119`	`audioStreamIndex);`
	`3120`	`}`
	`3121`	`else`
	`3122`	`{`
7	`3123`	`args += string.Format(`
7	`3124`	`CultureInfo.InvariantCulture,`
7	`3125`	`" -map 0:{0}",`
7	`3126`	`audioStreamIndex);`
	`3127`	`}`
	`3128`	`}`
	`3129`	`else`
	`3130`	`{`
0	`3131`	`args += " -map -0:a";`
	`3132`	`}`
	`3133`
7	`3134`	`var subtitleMethod = state.SubtitleDeliveryMethod;`
7	`3135`	`if (state.SubtitleStream is null \|\| subtitleMethod == SubtitleDeliveryMethod.Hls)`
	`3136`	`{`
1	`3137`	`args += " -map -0:s";`
	`3138`	`}`
6	`3139`	`else if (subtitleMethod == SubtitleDeliveryMethod.Embed)`
	`3140`	`{`
6	`3141`	`if (state.SubtitleStream.IsExternal)`
	`3142`	`{`
	`3143`	`// External subtitle file is added as second FFmpeg input.`
	`3144`	`// For single-stream files (SRT/ASS/VTT) the in-file index is always 0.`
	`3145`	`// For multi-stream containers (MKS) we count how many streams from`
	`3146`	`// the same file appear before the selected one.`
4	`3147`	`var inFileIndex = state.MediaSource.MediaStreams`
4	`3148`	`.Where(s => string.Equals(s.Path, state.SubtitleStream.Path, StringComparison.Ordinal))`
4	`3149`	`.TakeWhile(s => s.Index != state.SubtitleStream.Index)`
4	`3150`	`.Count();`
	`3151`
4	`3152`	`args += string.Format(`
4	`3153`	`CultureInfo.InvariantCulture,`
4	`3154`	`" -map 1:{0}",`
4	`3155`	`inFileIndex);`
	`3156`	`}`
	`3157`	`else`
	`3158`	`{`
2	`3159`	`int subtitleStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.SubtitleStream);`
	`3160`
2	`3161`	`args += string.Format(`
2	`3162`	`CultureInfo.InvariantCulture,`
2	`3163`	`" -map 0:{0}",`
2	`3164`	`subtitleStreamIndex);`
	`3165`	`}`
	`3166`	`}`
0	`3167`	`else if (state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)`
	`3168`	`{`
0	`3169`	`int externalSubtitleStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.SubtitleStream);`
	`3170`
0	`3171`	`args += string.Format(`
0	`3172`	`CultureInfo.InvariantCulture,`
0	`3173`	`" -map 1:{0} -sn",`
0	`3174`	`externalSubtitleStreamIndex);`
	`3175`	`}`
	`3176`
7	`3177`	`return args;`
	`3178`	`}`
	`3179`
	`3180`	`/// <summary>`
	`3181`	`/// Gets the negative map args by filters.`
	`3182`	`/// </summary>`
	`3183`	`/// <param name="state">The state.</param>`
	`3184`	`/// <param name="videoProcessFilters">The videoProcessFilters.</param>`
	`3185`	`/// <returns>System.String.</returns>`
	`3186`	`public string GetNegativeMapArgsByFilters(EncodingJobInfo state, string videoProcessFilters)`
	`3187`	`{`
0	`3188`	`string args = string.Empty;`
	`3189`
	`3190`	`// http://ffmpeg.org/ffmpeg-all.html#toc-Complex-filtergraphs-1`
0	`3191`	`if (state.VideoStream is not null && videoProcessFilters.Contains("-filter_complex", StringComparison.Ordina`
	`3192`	`{`
0	`3193`	`int videoStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.VideoStream);`
	`3194`
0	`3195`	`args += string.Format(`
0	`3196`	`CultureInfo.InvariantCulture,`
0	`3197`	`"-map -0:{0} ",`
0	`3198`	`videoStreamIndex);`
	`3199`	`}`
	`3200`
0	`3201`	`return args;`
	`3202`	`}`
	`3203`
	`3204`	`/// <summary>`
	`3205`	`/// Determines which stream will be used for playback.`
	`3206`	`/// </summary>`
	`3207`	`/// <param name="allStream">All stream.</param>`
	`3208`	`/// <param name="desiredIndex">Index of the desired.</param>`
	`3209`	`/// <param name="type">The type.</param>`
	`3210`	`/// <param name="returnFirstIfNoIndex">if set to <c>true</c> [return first if no index].</param>`
	`3211`	`/// <returns>MediaStream.</returns>`
	`3212`	`public MediaStream GetMediaStream(IEnumerable<MediaStream> allStream, int? desiredIndex, MediaStreamType type, b`
	`3213`	`{`
0	`3214`	`var streams = allStream.Where(s => s.Type == type).OrderBy(i => i.Index).ToList();`
	`3215`
0	`3216`	`if (desiredIndex.HasValue)`
	`3217`	`{`
0	`3218`	`var stream = streams.FirstOrDefault(s => s.Index == desiredIndex.Value);`
	`3219`
0	`3220`	`if (stream is not null)`
	`3221`	`{`
0	`3222`	`return stream;`
	`3223`	`}`
	`3224`	`}`
	`3225`
0	`3226`	`if (returnFirstIfNoIndex && type == MediaStreamType.Audio)`
	`3227`	`{`
0	`3228`	`return streams.FirstOrDefault(i => i.Channels.HasValue && i.Channels.Value > 0) ??`
0	`3229`	`streams.FirstOrDefault();`
	`3230`	`}`
	`3231`
	`3232`	`// Just return the first one`
0	`3233`	`return returnFirstIfNoIndex ? streams.FirstOrDefault() : null;`
	`3234`	`}`
	`3235`
	`3236`	`public static (int? Width, int? Height) GetFixedOutputSize(`
	`3237`	`int? videoWidth,`
	`3238`	`int? videoHeight,`
	`3239`	`int? requestedWidth,`
	`3240`	`int? requestedHeight,`
	`3241`	`int? requestedMaxWidth,`
	`3242`	`int? requestedMaxHeight)`
	`3243`	`{`
0	`3244`	`if (!videoWidth.HasValue && !requestedWidth.HasValue)`
	`3245`	`{`
0	`3246`	`return (null, null);`
	`3247`	`}`
	`3248`
0	`3249`	`if (!videoHeight.HasValue && !requestedHeight.HasValue)`
	`3250`	`{`
0	`3251`	`return (null, null);`
	`3252`	`}`
	`3253`
0	`3254`	`int inputWidth = Convert.ToInt32(videoWidth ?? requestedWidth, CultureInfo.InvariantCulture);`
0	`3255`	`int inputHeight = Convert.ToInt32(videoHeight ?? requestedHeight, CultureInfo.InvariantCulture);`
0	`3256`	`int outputWidth = requestedWidth ?? inputWidth;`
0	`3257`	`int outputHeight = requestedHeight ?? inputHeight;`
	`3258`
	`3259`	`// Don't transcode video to bigger than 4k when using HW.`
0	`3260`	`int maximumWidth = Math.Min(requestedMaxWidth ?? outputWidth, 4096);`
0	`3261`	`int maximumHeight = Math.Min(requestedMaxHeight ?? outputHeight, 4096);`
	`3262`
0	`3263`	`if (outputWidth > maximumWidth \|\| outputHeight > maximumHeight)`
	`3264`	`{`
0	`3265`	`var scaleW = (double)maximumWidth / outputWidth;`
0	`3266`	`var scaleH = (double)maximumHeight / outputHeight;`
0	`3267`	`var scale = Math.Min(scaleW, scaleH);`
0	`3268`	`outputWidth = Math.Min(maximumWidth, Convert.ToInt32(outputWidth * scale));`
0	`3269`	`outputHeight = Math.Min(maximumHeight, Convert.ToInt32(outputHeight * scale));`
	`3270`	`}`
	`3271`
0	`3272`	`outputWidth = 2 * (outputWidth / 2);`
0	`3273`	`outputHeight = 2 * (outputHeight / 2);`
	`3274`
0	`3275`	`return (outputWidth, outputHeight);`
	`3276`	`}`
	`3277`
	`3278`	`public static bool IsScaleRatioSupported(`
	`3279`	`int? videoWidth,`
	`3280`	`int? videoHeight,`
	`3281`	`int? requestedWidth,`
	`3282`	`int? requestedHeight,`
	`3283`	`int? requestedMaxWidth,`
	`3284`	`int? requestedMaxHeight,`
	`3285`	`double? maxScaleRatio)`
	`3286`	`{`
0	`3287`	`var (outWidth, outHeight) = GetFixedOutputSize(`
0	`3288`	`videoWidth,`
0	`3289`	`videoHeight,`
0	`3290`	`requestedWidth,`
0	`3291`	`requestedHeight,`
0	`3292`	`requestedMaxWidth,`
0	`3293`	`requestedMaxHeight);`
	`3294`
0	`3295`	`if (!videoWidth.HasValue`
0	`3296`	`\|\| !videoHeight.HasValue`
0	`3297`	`\|\| !outWidth.HasValue`
0	`3298`	`\|\| !outHeight.HasValue`
0	`3299`	`\|\| !maxScaleRatio.HasValue`
0	`3300`	`\|\| (maxScaleRatio.Value < 1.0f))`
	`3301`	`{`
0	`3302`	`return false;`
	`3303`	`}`
	`3304`
0	`3305`	`var minScaleRatio = 1.0f / maxScaleRatio;`
0	`3306`	`var scaleRatioW = (double)outWidth / (double)videoWidth;`
0	`3307`	`var scaleRatioH = (double)outHeight / (double)videoHeight;`
	`3308`
0	`3309`	`if (scaleRatioW < minScaleRatio`
0	`3310`	`\|\| scaleRatioW > maxScaleRatio`
0	`3311`	`\|\| scaleRatioH < minScaleRatio`
0	`3312`	`\|\| scaleRatioH > maxScaleRatio)`
	`3313`	`{`
0	`3314`	`return false;`
	`3315`	`}`
	`3316`
0	`3317`	`return true;`
	`3318`	`}`
	`3319`
	`3320`	`public static string GetHwScaleFilter(`
	`3321`	`string hwScalePrefix,`
	`3322`	`string hwScaleSuffix,`
	`3323`	`string videoFormat,`
	`3324`	`bool swapOutputWandH,`
	`3325`	`int? videoWidth,`
	`3326`	`int? videoHeight,`
	`3327`	`int? requestedWidth,`
	`3328`	`int? requestedHeight,`
	`3329`	`int? requestedMaxWidth,`
	`3330`	`int? requestedMaxHeight)`
	`3331`	`{`
0	`3332`	`var (outWidth, outHeight) = GetFixedOutputSize(`
0	`3333`	`videoWidth,`
0	`3334`	`videoHeight,`
0	`3335`	`requestedWidth,`
0	`3336`	`requestedHeight,`
0	`3337`	`requestedMaxWidth,`
0	`3338`	`requestedMaxHeight);`
	`3339`
0	`3340`	`var isFormatFixed = !string.IsNullOrEmpty(videoFormat);`
0	`3341`	`var isSizeFixed = !videoWidth.HasValue`
0	`3342`	`\|\| outWidth.Value != videoWidth.Value`
0	`3343`	`\|\| !videoHeight.HasValue`
0	`3344`	`\|\| outHeight.Value != videoHeight.Value;`
	`3345`
0	`3346`	`var swpOutW = swapOutputWandH ? outHeight.Value : outWidth.Value;`
0	`3347`	`var swpOutH = swapOutputWandH ? outWidth.Value : outHeight.Value;`
	`3348`
0	`3349`	`var arg1 = isSizeFixed ? $"=w={swpOutW}:h={swpOutH}" : string.Empty;`
0	`3350`	`var arg2 = isFormatFixed ? $"format={videoFormat}" : string.Empty;`
0	`3351`	`if (isFormatFixed)`
	`3352`	`{`
0	`3353`	`arg2 = (isSizeFixed ? ':' : '=') + arg2;`
	`3354`	`}`
	`3355`
0	`3356`	`if (!string.IsNullOrEmpty(hwScaleSuffix) && (isSizeFixed \|\| isFormatFixed))`
	`3357`	`{`
0	`3358`	`return string.Format(`
0	`3359`	`CultureInfo.InvariantCulture,`
0	`3360`	`"{0}_{1}{2}{3}",`
0	`3361`	`hwScalePrefix ?? "scale",`
0	`3362`	`hwScaleSuffix,`
0	`3363`	`arg1,`
0	`3364`	`arg2);`
	`3365`	`}`
	`3366`
0	`3367`	`return string.Empty;`
	`3368`	`}`
	`3369`
	`3370`	`public static string GetGraphicalSubPreProcessFilters(`
	`3371`	`int? videoWidth,`
	`3372`	`int? videoHeight,`
	`3373`	`int? subtitleWidth,`
	`3374`	`int? subtitleHeight,`
	`3375`	`int? requestedWidth,`
	`3376`	`int? requestedHeight,`
	`3377`	`int? requestedMaxWidth,`
	`3378`	`int? requestedMaxHeight)`
	`3379`	`{`
0	`3380`	`var (outWidth, outHeight) = GetFixedOutputSize(`
0	`3381`	`videoWidth,`
0	`3382`	`videoHeight,`
0	`3383`	`requestedWidth,`
0	`3384`	`requestedHeight,`
0	`3385`	`requestedMaxWidth,`
0	`3386`	`requestedMaxHeight);`
	`3387`
0	`3388`	`if (!outWidth.HasValue`
0	`3389`	`\|\| !outHeight.HasValue`
0	`3390`	`\|\| outWidth.Value <= 0`
0	`3391`	`\|\| outHeight.Value <= 0)`
	`3392`	`{`
0	`3393`	`return string.Empty;`
	`3394`	`}`
	`3395`
	`3396`	`// Automatically add padding based on subtitle input`
0	`3397`	`var filters = @"scale,scale=-1:{1}:fast_bilinear,crop,pad=max({0}\,iw):max({1}\,ih):(ow-iw)/2:(oh-ih)/2:blac`
	`3398`
0	`3399`	`if (subtitleWidth.HasValue`
0	`3400`	`&& subtitleHeight.HasValue`
0	`3401`	`&& subtitleWidth.Value > 0`
0	`3402`	`&& subtitleHeight.Value > 0)`
	`3403`	`{`
0	`3404`	`var videoDar = (double)outWidth.Value / outHeight.Value;`
0	`3405`	`var subtitleDar = (double)subtitleWidth.Value / subtitleHeight.Value;`
	`3406`
	`3407`	`// No need to add padding when DAR is the same -> 1080p PGSSUB on 2160p video`
0	`3408`	`if (Math.Abs(videoDar - subtitleDar) < 0.01f)`
	`3409`	`{`
0	`3410`	`filters = @"scale,scale={0}:{1}:fast_bilinear";`
	`3411`	`}`
	`3412`	`}`
	`3413`
0	`3414`	`return string.Format(`
0	`3415`	`CultureInfo.InvariantCulture,`
0	`3416`	`filters,`
0	`3417`	`outWidth.Value,`
0	`3418`	`outHeight.Value);`
	`3419`	`}`
	`3420`
	`3421`	`public static string GetAlphaSrcFilter(`
	`3422`	`EncodingJobInfo state,`
	`3423`	`int? videoWidth,`
	`3424`	`int? videoHeight,`
	`3425`	`int? requestedWidth,`
	`3426`	`int? requestedHeight,`
	`3427`	`int? requestedMaxWidth,`
	`3428`	`int? requestedMaxHeight,`
	`3429`	`float? framerate)`
	`3430`	`{`
0	`3431`	`var reqTicks = state.BaseRequest.StartTimeTicks ?? 0;`
0	`3432`	`var startTime = TimeSpan.FromTicks(reqTicks).ToString(@"hh\\\:mm\\\:ss\\\.fff", CultureInfo.InvariantCulture`
0	`3433`	`var (outWidth, outHeight) = GetFixedOutputSize(`
0	`3434`	`videoWidth,`
0	`3435`	`videoHeight,`
0	`3436`	`requestedWidth,`
0	`3437`	`requestedHeight,`
0	`3438`	`requestedMaxWidth,`
0	`3439`	`requestedMaxHeight);`
	`3440`
0	`3441`	`if (outWidth.HasValue && outHeight.HasValue)`
	`3442`	`{`
0	`3443`	`return string.Format(`
0	`3444`	`CultureInfo.InvariantCulture,`
0	`3445`	`"alphasrc=s={0}x{1}:r={2}:start='{3}'",`
0	`3446`	`outWidth.Value,`
0	`3447`	`outHeight.Value,`
0	`3448`	`framerate ?? 25,`
0	`3449`	`reqTicks > 0 ? startTime : 0);`
	`3450`	`}`
	`3451`
0	`3452`	`return string.Empty;`
	`3453`	`}`
	`3454`
	`3455`	`public static string GetSwScaleFilter(`
	`3456`	`EncodingJobInfo state,`
	`3457`	`EncodingOptions options,`
	`3458`	`string videoEncoder,`
	`3459`	`int? videoWidth,`
	`3460`	`int? videoHeight,`
	`3461`	`Video3DFormat? threedFormat,`
	`3462`	`int? requestedWidth,`
	`3463`	`int? requestedHeight,`
	`3464`	`int? requestedMaxWidth,`
	`3465`	`int? requestedMaxHeight)`
	`3466`	`{`
0	`3467`	`var isV4l2 = string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase);`
0	`3468`	`var isMjpeg = videoEncoder is not null && videoEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase)`
0	`3469`	`var scaleVal = isV4l2 ? 64 : 2;`
0	`3470`	`var targetAr = isMjpeg ? "(a*sar)" : "a"; // manually calculate AR when using mjpeg encoder`
	`3471`
	`3472`	`// If fixed dimensions were supplied`
0	`3473`	`if (requestedWidth.HasValue && requestedHeight.HasValue)`
	`3474`	`{`
0	`3475`	`if (isV4l2)`
	`3476`	`{`
0	`3477`	`var widthParam = requestedWidth.Value.ToString(CultureInfo.InvariantCulture);`
0	`3478`	`var heightParam = requestedHeight.Value.ToString(CultureInfo.InvariantCulture);`
	`3479`
0	`3480`	`return string.Format(`
0	`3481`	`CultureInfo.InvariantCulture,`
0	`3482`	`"scale=trunc({0}/64)64:trunc({1}/2)2",`
0	`3483`	`widthParam,`
0	`3484`	`heightParam);`
	`3485`	`}`
	`3486`
0	`3487`	`return GetFixedSwScaleFilter(threedFormat, requestedWidth.Value, requestedHeight.Value);`
	`3488`	`}`
	`3489`
	`3490`	`// If Max dimensions were supplied, for width selects lowest even number between input width and width req s`
	`3491`
0	`3492`	`if (requestedMaxWidth.HasValue && requestedMaxHeight.HasValue)`
	`3493`	`{`
0	`3494`	`var maxWidthParam = requestedMaxWidth.Value.ToString(CultureInfo.InvariantCulture);`
0	`3495`	`var maxHeightParam = requestedMaxHeight.Value.ToString(CultureInfo.InvariantCulture);`
	`3496`
0	`3497`	`return string.Format(`
0	`3498`	`CultureInfo.InvariantCulture,`
0	`3499`	`@"scale=trunc(min(max(iw\,ih{3})\,min({0}\,{1}{3}))/{2})*{2}:trunc(min(max(iw/{3}\,ih)\,min({0}/{3`
0	`3500`	`maxWidthParam,`
0	`3501`	`maxHeightParam,`
0	`3502`	`scaleVal,`
0	`3503`	`targetAr);`
	`3504`	`}`
	`3505`
	`3506`	`// If a fixed width was requested`
0	`3507`	`if (requestedWidth.HasValue)`
	`3508`	`{`
0	`3509`	`if (threedFormat.HasValue)`
	`3510`	`{`
	`3511`	`// This method can handle 0 being passed in for the requested height`
0	`3512`	`return GetFixedSwScaleFilter(threedFormat, requestedWidth.Value, 0);`
	`3513`	`}`
	`3514`
0	`3515`	`var widthParam = requestedWidth.Value.ToString(CultureInfo.InvariantCulture);`
	`3516`
0	`3517`	`return string.Format(`
0	`3518`	`CultureInfo.InvariantCulture,`
0	`3519`	`"scale={0}:trunc(ow/{1}/2)*2",`
0	`3520`	`widthParam,`
0	`3521`	`targetAr);`
	`3522`	`}`
	`3523`
	`3524`	`// If a fixed height was requested`
0	`3525`	`if (requestedHeight.HasValue)`
	`3526`	`{`
0	`3527`	`var heightParam = requestedHeight.Value.ToString(CultureInfo.InvariantCulture);`
	`3528`
0	`3529`	`return string.Format(`
0	`3530`	`CultureInfo.InvariantCulture,`
0	`3531`	`"scale=trunc(oh{2}/{1}){1}:{0}",`
0	`3532`	`heightParam,`
0	`3533`	`scaleVal,`
0	`3534`	`targetAr);`
	`3535`	`}`
	`3536`
	`3537`	`// If a max width was requested`
0	`3538`	`if (requestedMaxWidth.HasValue)`
	`3539`	`{`
0	`3540`	`var maxWidthParam = requestedMaxWidth.Value.ToString(CultureInfo.InvariantCulture);`
	`3541`
0	`3542`	`return string.Format(`
0	`3543`	`CultureInfo.InvariantCulture,`
0	`3544`	`@"scale=trunc(min(max(iw\,ih{2})\,{0})/{1}){1}:trunc(ow/{2}/2)*2",`
0	`3545`	`maxWidthParam,`
0	`3546`	`scaleVal,`
0	`3547`	`targetAr);`
	`3548`	`}`
	`3549`
	`3550`	`// If a max height was requested`
0	`3551`	`if (requestedMaxHeight.HasValue)`
	`3552`	`{`
0	`3553`	`var maxHeightParam = requestedMaxHeight.Value.ToString(CultureInfo.InvariantCulture);`
	`3554`
0	`3555`	`return string.Format(`
0	`3556`	`CultureInfo.InvariantCulture,`
0	`3557`	`@"scale=trunc(oh{2}/{1}){1}:min(max(iw/{2}\,ih)\,{0})",`
0	`3558`	`maxHeightParam,`
0	`3559`	`scaleVal,`
0	`3560`	`targetAr);`
	`3561`	`}`
	`3562`
0	`3563`	`return string.Empty;`
	`3564`	`}`
	`3565`
	`3566`	`private static string GetFixedSwScaleFilter(Video3DFormat? threedFormat, int requestedWidth, int requestedHeight`
	`3567`	`{`
0	`3568`	`var widthParam = requestedWidth.ToString(CultureInfo.InvariantCulture);`
0	`3569`	`var heightParam = requestedHeight.ToString(CultureInfo.InvariantCulture);`
	`3570`
0	`3571`	`string filter = null;`
	`3572`
0	`3573`	`if (threedFormat.HasValue)`
	`3574`	`{`
0	`3575`	`switch (threedFormat.Value)`
	`3576`	`{`
	`3577`	`case Video3DFormat.HalfSideBySide:`
0	`3578`	`filter = @"crop=iw/2:ih:0:0,scale=(iw2):ih,setdar=dar=a,crop=min(iw\,ihdar):min(ih\,iw/dar):(i`
	`3579`	`// hsbs crop width in half,scale to correct size, set the display aspect,crop out any black bars`
0	`3580`	`break;`
	`3581`	`case Video3DFormat.FullSideBySide:`
0	`3582`	`filter = @"crop=iw/2:ih:0:0,setdar=dar=a,crop=min(iw\,ihdar):min(ih\,iw/dar):(iw-min(iw\,iwsar`
	`3583`	`// fsbs crop width in half,set the display aspect,crop out any black bars we may have made the s`
0	`3584`	`break;`
	`3585`	`case Video3DFormat.HalfTopAndBottom:`
0	`3586`	`filter = @"crop=iw:ih/2:0:0,scale=(iw2):ih),setdar=dar=a,crop=min(iw\,ihdar):min(ih\,iw/dar):(`
	`3587`	`// htab crop height in half,scale to correct size, set the display aspect,crop out any black bar`
0	`3588`	`break;`
	`3589`	`case Video3DFormat.FullTopAndBottom:`
0	`3590`	`filter = @"crop=iw:ih/2:0:0,setdar=dar=a,crop=min(iw\,ihdar):min(ih\,iw/dar):(iw-min(iw\,iwsar`
	`3591`	`// ftab crop height in half, set the display aspect,crop out any black bars we may have made the`
	`3592`	`break;`
	`3593`	`default:`
	`3594`	`break;`
	`3595`	`}`
	`3596`	`}`
	`3597`
	`3598`	`// default`
0	`3599`	`if (filter is null)`
	`3600`	`{`
0	`3601`	`if (requestedHeight > 0)`
	`3602`	`{`
0	`3603`	`filter = "scale=trunc({0}/2)2:trunc({1}/2)2";`
	`3604`	`}`
	`3605`	`else`
	`3606`	`{`
0	`3607`	`filter = "scale={0}:trunc({0}/a/2)*2";`
	`3608`	`}`
	`3609`	`}`
	`3610`
0	`3611`	`return string.Format(CultureInfo.InvariantCulture, filter, widthParam, heightParam);`
	`3612`	`}`
	`3613`
	`3614`	`public static string GetSwDeinterlaceFilter(EncodingJobInfo state, EncodingOptions options)`
	`3615`	`{`
0	`3616`	`var doubleRateDeint = options.DeinterlaceDoubleRate && state.VideoStream?.ReferenceFrameRate <= 30;`
0	`3617`	`return string.Format(`
0	`3618`	`CultureInfo.InvariantCulture,`
0	`3619`	`"{0}={1}:-1:0",`
0	`3620`	`options.DeinterlaceMethod.ToString().ToLowerInvariant(),`
0	`3621`	`doubleRateDeint ? "1" : "0");`
	`3622`	`}`
	`3623`
	`3624`	`public string GetHwDeinterlaceFilter(EncodingJobInfo state, EncodingOptions options, string hwDeintSuffix)`
	`3625`	`{`
0	`3626`	`var doubleRateDeint = options.DeinterlaceDoubleRate && (state.VideoStream?.ReferenceFrameRate ?? 60) <= 30;`
0	`3627`	`if (hwDeintSuffix.Contains("cuda", StringComparison.OrdinalIgnoreCase))`
	`3628`	`{`
0	`3629`	`var useBwdif = options.DeinterlaceMethod == DeinterlaceMethod.bwdif && _mediaEncoder.SupportsFilter("bwd`
	`3630`
0	`3631`	`return string.Format(`
0	`3632`	`CultureInfo.InvariantCulture,`
0	`3633`	`"{0}_cuda={1}:-1:0",`
0	`3634`	`useBwdif ? "bwdif" : "yadif",`
0	`3635`	`doubleRateDeint ? "1" : "0");`
	`3636`	`}`
	`3637`
0	`3638`	`if (hwDeintSuffix.Contains("opencl", StringComparison.OrdinalIgnoreCase))`
	`3639`	`{`
0	`3640`	`var useBwdif = options.DeinterlaceMethod == DeinterlaceMethod.bwdif;`
	`3641`
0	`3642`	`if (_mediaEncoder.SupportsFilter("yadif_opencl")`
0	`3643`	`&& _mediaEncoder.SupportsFilter("bwdif_opencl"))`
	`3644`	`{`
0	`3645`	`return string.Format(`
0	`3646`	`CultureInfo.InvariantCulture,`
0	`3647`	`"{0}_opencl={1}:-1:0",`
0	`3648`	`useBwdif ? "bwdif" : "yadif",`
0	`3649`	`doubleRateDeint ? "1" : "0");`
	`3650`	`}`
	`3651`	`}`
	`3652`
0	`3653`	`if (hwDeintSuffix.Contains("vaapi", StringComparison.OrdinalIgnoreCase))`
	`3654`	`{`
0	`3655`	`return string.Format(`
0	`3656`	`CultureInfo.InvariantCulture,`
0	`3657`	`"deinterlace_vaapi=rate={0}",`
0	`3658`	`doubleRateDeint ? "field" : "frame");`
	`3659`	`}`
	`3660`
0	`3661`	`if (hwDeintSuffix.Contains("qsv", StringComparison.OrdinalIgnoreCase))`
	`3662`	`{`
0	`3663`	`return "deinterlace_qsv=mode=2";`
	`3664`	`}`
	`3665`
0	`3666`	`if (hwDeintSuffix.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase))`
	`3667`	`{`
0	`3668`	`var useBwdif = options.DeinterlaceMethod == DeinterlaceMethod.bwdif && _mediaEncoder.SupportsFilter("bwd`
	`3669`
0	`3670`	`return string.Format(`
0	`3671`	`CultureInfo.InvariantCulture,`
0	`3672`	`"{0}_videotoolbox={1}:-1:0",`
0	`3673`	`useBwdif ? "bwdif" : "yadif",`
0	`3674`	`doubleRateDeint ? "1" : "0");`
	`3675`	`}`
	`3676`
0	`3677`	`return string.Empty;`
	`3678`	`}`
	`3679`
	`3680`	`private string GetHwTonemapFilter(EncodingOptions options, string hwTonemapSuffix, string videoFormat, bool forc`
	`3681`	`{`
0	`3682`	`if (string.IsNullOrEmpty(hwTonemapSuffix))`
	`3683`	`{`
0	`3684`	`return string.Empty;`
	`3685`	`}`
	`3686`
0	`3687`	`var args = string.Empty;`
0	`3688`	`var algorithm = options.TonemappingAlgorithm.ToString().ToLowerInvariant();`
0	`3689`	`var mode = options.TonemappingMode.ToString().ToLowerInvariant();`
0	`3690`	`var range = forceFullRange ? TonemappingRange.pc : options.TonemappingRange;`
0	`3691`	`var rangeString = range.ToString().ToLowerInvariant();`
	`3692`
0	`3693`	`if (string.Equals(hwTonemapSuffix, "vaapi", StringComparison.OrdinalIgnoreCase))`
	`3694`	`{`
0	`3695`	`var doVaVppProcamp = false;`
0	`3696`	`var procampParams = string.Empty;`
0	`3697`	`if (options.VppTonemappingBrightness != 0`
0	`3698`	`&& options.VppTonemappingBrightness >= -100`
0	`3699`	`&& options.VppTonemappingBrightness <= 100)`
	`3700`	`{`
0	`3701`	`procampParams += "procamp_vaapi=b={0}";`
0	`3702`	`doVaVppProcamp = true;`
	`3703`	`}`
	`3704`
0	`3705`	`if (options.VppTonemappingContrast > 1`
0	`3706`	`&& options.VppTonemappingContrast <= 10)`
	`3707`	`{`
0	`3708`	`procampParams += doVaVppProcamp ? ":c={1}" : "procamp_vaapi=c={1}";`
0	`3709`	`doVaVppProcamp = true;`
	`3710`	`}`
	`3711`
0	`3712`	`args = procampParams + "{2}tonemap_vaapi=format={3}:p=bt709:t=bt709:m=bt709:extra_hw_frames=32";`
	`3713`
0	`3714`	`return string.Format(`
0	`3715`	`CultureInfo.InvariantCulture,`
0	`3716`	`args,`
0	`3717`	`options.VppTonemappingBrightness,`
0	`3718`	`options.VppTonemappingContrast,`
0	`3719`	`doVaVppProcamp ? "," : string.Empty,`
0	`3720`	`videoFormat ?? "nv12");`
	`3721`	`}`
	`3722`	`else`
	`3723`	`{`
0	`3724`	`args = "tonemap_{0}=format={1}:p=bt709:t=bt709:m=bt709:tonemap={2}:peak={3}:desat={4}";`
	`3725`
0	`3726`	`var useLegacyTonemapModes = _mediaEncoder.EncoderVersion >= _minFFmpegOclCuTonemapMode`
0	`3727`	`&& _legacyTonemapModes.Contains(options.TonemappingMode);`
	`3728`
0	`3729`	`var useAdvancedTonemapModes = _mediaEncoder.EncoderVersion >= _minFFmpegAdvancedTonemapMode`
0	`3730`	`&& _advancedTonemapModes.Contains(options.TonemappingMode);`
	`3731`
0	`3732`	`if (useLegacyTonemapModes \|\| useAdvancedTonemapModes)`
	`3733`	`{`
0	`3734`	`args += ":tonemap_mode={5}";`
	`3735`	`}`
	`3736`
0	`3737`	`if (options.TonemappingParam != 0)`
	`3738`	`{`
0	`3739`	`args += ":param={6}";`
	`3740`	`}`
	`3741`
0	`3742`	`if (range == TonemappingRange.tv \|\| range == TonemappingRange.pc)`
	`3743`	`{`
0	`3744`	`args += ":range={7}";`
	`3745`	`}`
	`3746`	`}`
	`3747`
0	`3748`	`return string.Format(`
0	`3749`	`CultureInfo.InvariantCulture,`
0	`3750`	`args,`
0	`3751`	`hwTonemapSuffix,`
0	`3752`	`videoFormat ?? "nv12",`
0	`3753`	`algorithm,`
0	`3754`	`options.TonemappingPeak,`
0	`3755`	`options.TonemappingDesat,`
0	`3756`	`mode,`
0	`3757`	`options.TonemappingParam,`
0	`3758`	`rangeString);`
	`3759`	`}`
	`3760`
	`3761`	`private string GetLibplaceboFilter(`
	`3762`	`EncodingOptions options,`
	`3763`	`string videoFormat,`
	`3764`	`bool doTonemap,`
	`3765`	`int? videoWidth,`
	`3766`	`int? videoHeight,`
	`3767`	`int? requestedWidth,`
	`3768`	`int? requestedHeight,`
	`3769`	`int? requestedMaxWidth,`
	`3770`	`int? requestedMaxHeight,`
	`3771`	`bool forceFullRange)`
	`3772`	`{`
0	`3773`	`var (outWidth, outHeight) = GetFixedOutputSize(`
0	`3774`	`videoWidth,`
0	`3775`	`videoHeight,`
0	`3776`	`requestedWidth,`
0	`3777`	`requestedHeight,`
0	`3778`	`requestedMaxWidth,`
0	`3779`	`requestedMaxHeight);`
	`3780`
0	`3781`	`var isFormatFixed = !string.IsNullOrEmpty(videoFormat);`
0	`3782`	`var isSizeFixed = !videoWidth.HasValue`
0	`3783`	`\|\| outWidth.Value != videoWidth.Value`
0	`3784`	`\|\| !videoHeight.HasValue`
0	`3785`	`\|\| outHeight.Value != videoHeight.Value;`
	`3786`
0	`3787`	`var sizeArg = isSizeFixed ? (":w=" + outWidth.Value + ":h=" + outHeight.Value) : string.Empty;`
0	`3788`	`var formatArg = isFormatFixed ? (":format=" + videoFormat) : string.Empty;`
0	`3789`	`var tonemapArg = string.Empty;`
	`3790`
0	`3791`	`if (doTonemap)`
	`3792`	`{`
0	`3793`	`var algorithm = options.TonemappingAlgorithm;`
0	`3794`	`var algorithmString = "clip";`
0	`3795`	`var mode = options.TonemappingMode;`
0	`3796`	`var range = forceFullRange ? TonemappingRange.pc : options.TonemappingRange;`
	`3797`
0	`3798`	`if (algorithm == TonemappingAlgorithm.bt2390)`
	`3799`	`{`
0	`3800`	`algorithmString = "bt.2390";`
	`3801`	`}`
0	`3802`	`else if (algorithm != TonemappingAlgorithm.none)`
	`3803`	`{`
0	`3804`	`algorithmString = algorithm.ToString().ToLowerInvariant();`
	`3805`	`}`
	`3806`
0	`3807`	`tonemapArg = $":tonemapping={algorithmString}:peak_detect=0:color_primaries=bt709:color_trc=bt709:colors`
	`3808`
0	`3809`	`if (range == TonemappingRange.tv \|\| range == TonemappingRange.pc)`
	`3810`	`{`
0	`3811`	`tonemapArg += ":range=" + range.ToString().ToLowerInvariant();`
	`3812`	`}`
	`3813`	`}`
	`3814`
0	`3815`	`return string.Format(`
0	`3816`	`CultureInfo.InvariantCulture,`
0	`3817`	`"libplacebo=upscaler=none:downscaler=none{0}{1}{2}",`
0	`3818`	`sizeArg,`
0	`3819`	`formatArg,`
0	`3820`	`tonemapArg);`
	`3821`	`}`
	`3822`
	`3823`	`public string GetVideoTransposeDirection(EncodingJobInfo state)`
	`3824`	`{`
0	`3825`	`return (state.VideoStream?.Rotation ?? 0) switch`
0	`3826`	`{`
0	`3827`	`90 => "cclock",`
0	`3828`	`180 => "reversal",`
0	`3829`	`-90 => "clock",`
0	`3830`	`-180 => "reversal",`
0	`3831`	`_ => string.Empty`
0	`3832`	`};`
	`3833`	`}`
	`3834`
	`3835`	`/// <summary>`
	`3836`	`/// Gets the parameter of software filter chain.`
	`3837`	`/// </summary>`
	`3838`	`/// <param name="state">Encoding state.</param>`
	`3839`	`/// <param name="options">Encoding options.</param>`
	`3840`	`/// <param name="vidEncoder">Video encoder to use.</param>`
	`3841`	`/// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>`
	`3842`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetSwVidFilterChain(`
	`3843`	`EncodingJobInfo state,`
	`3844`	`EncodingOptions options,`
	`3845`	`string vidEncoder)`
	`3846`	`{`
0	`3847`	`var inW = state.VideoStream?.Width;`
0	`3848`	`var inH = state.VideoStream?.Height;`
0	`3849`	`var reqW = state.BaseRequest.Width;`
0	`3850`	`var reqH = state.BaseRequest.Height;`
0	`3851`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`3852`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`3853`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`3854`
0	`3855`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
0	`3856`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`3857`	`var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`3858`	`var isV4l2Encoder = vidEncoder.Contains("h264_v4l2m2m", StringComparison.OrdinalIgnoreCase);`
	`3859`
0	`3860`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
0	`3861`	`var doToneMap = IsSwTonemapAvailable(state, options);`
0	`3862`	`var requireDoviReshaping = doToneMap && state.VideoStream.VideoRangeType == VideoRangeType.DOVI;`
	`3863`
0	`3864`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`3865`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`3866`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
	`3867`
0	`3868`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`3869`	`var swapWAndH = Math.Abs(rotation) == 90;`
0	`3870`	`var swpInW = swapWAndH ? inH : inW;`
0	`3871`	`var swpInH = swapWAndH ? inW : inH;`
	`3872`
	`3873`	`/* Make main filters for video stream */`
0	`3874`	`var mainFilters = new List<string>();`
	`3875`
0	`3876`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doToneMap));`
	`3877`
	`3878`	`// INPUT sw surface(memory/copy-back from vram)`
	`3879`	`// sw deint`
0	`3880`	`if (doDeintH2645)`
	`3881`	`{`
0	`3882`	`var deintFilter = GetSwDeinterlaceFilter(state, options);`
0	`3883`	`mainFilters.Add(deintFilter);`
	`3884`	`}`
	`3885`
0	`3886`	`var outFormat = isSwDecoder ? "yuv420p" : "nv12";`
0	`3887`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, reqH, r`
0	`3888`	`if (isVaapiEncoder)`
	`3889`	`{`
0	`3890`	`outFormat = "nv12";`
	`3891`	`}`
0	`3892`	`else if (isV4l2Encoder)`
	`3893`	`{`
0	`3894`	`outFormat = "yuv420p";`
	`3895`	`}`
	`3896`
	`3897`	`// sw scale`
0	`3898`	`mainFilters.Add(swScaleFilter);`
	`3899`
	`3900`	`// sw tonemap`
0	`3901`	`if (doToneMap)`
	`3902`	`{`
	`3903`	`// tonemapx requires yuv420p10 input for dovi reshaping, let ffmpeg convert the frame when necessary`
0	`3904`	`var tonemapFormat = requireDoviReshaping ? "yuv420p" : outFormat;`
0	`3905`	`var tonemapArgString = "tonemapx=tonemap={0}:desat={1}:peak={2}:t=bt709:m=bt709:p=bt709:format={3}";`
	`3906`
0	`3907`	`if (options.TonemappingParam != 0)`
	`3908`	`{`
0	`3909`	`tonemapArgString += ":param={4}";`
	`3910`	`}`
	`3911`
0	`3912`	`var range = options.TonemappingRange;`
0	`3913`	`if (range == TonemappingRange.tv \|\| range == TonemappingRange.pc)`
	`3914`	`{`
0	`3915`	`tonemapArgString += ":range={5}";`
	`3916`	`}`
	`3917`
0	`3918`	`var tonemapArgs = string.Format(`
0	`3919`	`CultureInfo.InvariantCulture,`
0	`3920`	`tonemapArgString,`
0	`3921`	`options.TonemappingAlgorithm,`
0	`3922`	`options.TonemappingDesat,`
0	`3923`	`options.TonemappingPeak,`
0	`3924`	`tonemapFormat,`
0	`3925`	`options.TonemappingParam,`
0	`3926`	`options.TonemappingRange);`
	`3927`
0	`3928`	`mainFilters.Add(tonemapArgs);`
	`3929`	`}`
	`3930`	`else`
	`3931`	`{`
	`3932`	`// OUTPUT yuv420p/nv12 surface(memory)`
0	`3933`	`mainFilters.Add("format=" + outFormat);`
	`3934`	`}`
	`3935`
	`3936`	`/* Make sub and overlay filters for subtitle stream */`
0	`3937`	`var subFilters = new List<string>();`
0	`3938`	`var overlayFilters = new List<string>();`
0	`3939`	`if (hasTextSubs)`
	`3940`	`{`
	`3941`	`// subtitles=f='*.ass':alpha=0`
0	`3942`	`var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);`
0	`3943`	`mainFilters.Add(textSubtitlesFilter);`
	`3944`	`}`
0	`3945`	`else if (hasGraphicalSubs)`
	`3946`	`{`
0	`3947`	`var subW = state.SubtitleStream?.Width;`
0	`3948`	`var subH = state.SubtitleStream?.Height;`
0	`3949`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, reqMaxW`
0	`3950`	`subFilters.Add(subPreProcFilters);`
0	`3951`	`overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");`
	`3952`	`}`
	`3953`
0	`3954`	`return (mainFilters, subFilters, overlayFilters);`
	`3955`	`}`
	`3956`
	`3957`	`/// <summary>`
	`3958`	`/// Gets the parameter of Nvidia NVENC filter chain.`
	`3959`	`/// </summary>`
	`3960`	`/// <param name="state">Encoding state.</param>`
	`3961`	`/// <param name="options">Encoding options.</param>`
	`3962`	`/// <param name="vidEncoder">Video encoder to use.</param>`
	`3963`	`/// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>`
	`3964`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetNvidiaVidFilterChain(`
	`3965`	`EncodingJobInfo state,`
	`3966`	`EncodingOptions options,`
	`3967`	`string vidEncoder)`
	`3968`	`{`
0	`3969`	`if (options.HardwareAccelerationType != HardwareAccelerationType.nvenc)`
	`3970`	`{`
0	`3971`	`return (null, null, null);`
	`3972`	`}`
	`3973`
0	`3974`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
0	`3975`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`3976`	`var isSwEncoder = !vidEncoder.Contains("nvenc", StringComparison.OrdinalIgnoreCase);`
	`3977`
	`3978`	`// legacy cuvid pipeline(copy-back)`
0	`3979`	`if ((isSwDecoder && isSwEncoder)`
0	`3980`	`\|\| !IsCudaFullSupported()`
0	`3981`	`\|\| !_mediaEncoder.SupportsFilter("alphasrc"))`
	`3982`	`{`
0	`3983`	`return GetSwVidFilterChain(state, options, vidEncoder);`
	`3984`	`}`
	`3985`
	`3986`	`// preferred nvdec/cuvid + cuda filters + nvenc pipeline`
0	`3987`	`return GetNvidiaVidFiltersPrefered(state, options, vidDecoder, vidEncoder);`
	`3988`	`}`
	`3989`
	`3990`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetNvidiaVidFiltersPrefe`
	`3991`	`EncodingJobInfo state,`
	`3992`	`EncodingOptions options,`
	`3993`	`string vidDecoder,`
	`3994`	`string vidEncoder)`
	`3995`	`{`
0	`3996`	`var inW = state.VideoStream?.Width;`
0	`3997`	`var inH = state.VideoStream?.Height;`
0	`3998`	`var reqW = state.BaseRequest.Width;`
0	`3999`	`var reqH = state.BaseRequest.Height;`
0	`4000`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`4001`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`4002`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`4003`
0	`4004`	`var isNvDecoder = vidDecoder.Contains("cuda", StringComparison.OrdinalIgnoreCase);`
0	`4005`	`var isNvencEncoder = vidEncoder.Contains("nvenc", StringComparison.OrdinalIgnoreCase);`
0	`4006`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`4007`	`var isSwEncoder = !isNvencEncoder;`
0	`4008`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
0	`4009`	`var isCuInCuOut = isNvDecoder && isNvencEncoder;`
	`4010`
0	`4011`	`var doubleRateDeint = options.DeinterlaceDoubleRate && (state.VideoStream?.ReferenceFrameRate ?? 60) <= 30;`
0	`4012`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
0	`4013`	`var doCuTonemap = IsHwTonemapAvailable(state, options);`
	`4014`
0	`4015`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`4016`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`4017`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
0	`4018`	`var hasAssSubs = hasSubs`
0	`4019`	`&& (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)`
0	`4020`	`\|\| string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));`
0	`4021`	`var subW = state.SubtitleStream?.Width;`
0	`4022`	`var subH = state.SubtitleStream?.Height;`
	`4023`
0	`4024`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`4025`	`var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);`
0	`4026`	`var doCuTranspose = !string.IsNullOrEmpty(transposeDir) && _mediaEncoder.SupportsFilter("transpose_cuda");`
0	`4027`	`var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder \|\| (isNvDecoder && doCuTranspose));`
0	`4028`	`var swpInW = swapWAndH ? inH : inW;`
0	`4029`	`var swpInH = swapWAndH ? inW : inH;`
	`4030`
	`4031`	`/* Make main filters for video stream */`
0	`4032`	`var mainFilters = new List<string>();`
	`4033`
0	`4034`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doCuTonemap));`
	`4035`
0	`4036`	`if (isSwDecoder)`
	`4037`	`{`
	`4038`	`// INPUT sw surface(memory)`
	`4039`	`// sw deint`
0	`4040`	`if (doDeintH2645)`
	`4041`	`{`
0	`4042`	`var swDeintFilter = GetSwDeinterlaceFilter(state, options);`
0	`4043`	`mainFilters.Add(swDeintFilter);`
	`4044`	`}`
	`4045`
0	`4046`	`var outFormat = doCuTonemap ? "yuv420p10le" : "yuv420p";`
0	`4047`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req`
	`4048`	`// sw scale`
0	`4049`	`mainFilters.Add(swScaleFilter);`
0	`4050`	`mainFilters.Add($"format={outFormat}");`
	`4051`
	`4052`	`// sw => hw`
0	`4053`	`if (doCuTonemap)`
	`4054`	`{`
0	`4055`	`mainFilters.Add("hwupload=derive_device=cuda");`
	`4056`	`}`
	`4057`	`}`
	`4058`
0	`4059`	`if (isNvDecoder)`
	`4060`	`{`
	`4061`	`// INPUT cuda surface(vram)`
	`4062`	`// hw deint`
0	`4063`	`if (doDeintH2645)`
	`4064`	`{`
0	`4065`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "cuda");`
0	`4066`	`mainFilters.Add(deintFilter);`
	`4067`	`}`
	`4068`
	`4069`	`// hw transpose`
0	`4070`	`if (doCuTranspose)`
	`4071`	`{`
0	`4072`	`mainFilters.Add($"transpose_cuda=dir={transposeDir}");`
	`4073`	`}`
	`4074`
0	`4075`	`var isRext = IsVideoStreamHevcRext(state);`
0	`4076`	`var outFormat = doCuTonemap ? (isRext ? "p010" : string.Empty) : "yuv420p";`
0	`4077`	`var hwScaleFilter = GetHwScaleFilter("scale", "cuda", outFormat, false, swpInW, swpInH, reqW, reqH, reqM`
	`4078`	`// hw scale`
0	`4079`	`mainFilters.Add(hwScaleFilter);`
	`4080`	`}`
	`4081`
	`4082`	`// hw tonemap`
0	`4083`	`if (doCuTonemap)`
	`4084`	`{`
0	`4085`	`var tonemapFilter = GetHwTonemapFilter(options, "cuda", "yuv420p", isMjpegEncoder);`
0	`4086`	`mainFilters.Add(tonemapFilter);`
	`4087`	`}`
	`4088`
0	`4089`	`var memoryOutput = false;`
0	`4090`	`var isUploadForCuTonemap = isSwDecoder && doCuTonemap;`
0	`4091`	`if ((isNvDecoder && isSwEncoder) \|\| (isUploadForCuTonemap && hasSubs))`
	`4092`	`{`
0	`4093`	`memoryOutput = true;`
	`4094`
	`4095`	`// OUTPUT yuv420p surface(memory)`
0	`4096`	`mainFilters.Add("hwdownload");`
0	`4097`	`mainFilters.Add("format=yuv420p");`
	`4098`	`}`
	`4099`
	`4100`	`// OUTPUT yuv420p surface(memory)`
0	`4101`	`if (isSwDecoder && isNvencEncoder && !isUploadForCuTonemap)`
	`4102`	`{`
0	`4103`	`memoryOutput = true;`
	`4104`	`}`
	`4105`
0	`4106`	`if (memoryOutput)`
	`4107`	`{`
	`4108`	`// text subtitles`
0	`4109`	`if (hasTextSubs)`
	`4110`	`{`
0	`4111`	`var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);`
0	`4112`	`mainFilters.Add(textSubtitlesFilter);`
	`4113`	`}`
	`4114`	`}`
	`4115`
	`4116`	`// OUTPUT cuda(yuv420p) surface(vram)`
	`4117`
	`4118`	`/* Make sub and overlay filters for subtitle stream */`
0	`4119`	`var subFilters = new List<string>();`
0	`4120`	`var overlayFilters = new List<string>();`
0	`4121`	`if (isCuInCuOut)`
	`4122`	`{`
0	`4123`	`if (hasSubs)`
	`4124`	`{`
0	`4125`	`var alphaFormatOpt = string.Empty;`
0	`4126`	`if (hasGraphicalSubs)`
	`4127`	`{`
0	`4128`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,`
0	`4129`	`subFilters.Add(subPreProcFilters);`
0	`4130`	`subFilters.Add("format=yuva420p");`
	`4131`	`}`
0	`4132`	`else if (hasTextSubs)`
	`4133`	`{`
0	`4134`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`4135`	`var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;`
	`4136`
	`4137`	`// alphasrc=s=1280x720:r=10:start=0,format=yuva420p,subtitles,hwupload`
0	`4138`	`var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH, subF`
0	`4139`	`var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);`
0	`4140`	`subFilters.Add(alphaSrcFilter);`
0	`4141`	`subFilters.Add("format=yuva420p");`
0	`4142`	`subFilters.Add(subTextSubtitlesFilter);`
	`4143`
0	`4144`	`alphaFormatOpt = _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayCudaAlphaFormat)`
0	`4145`	`? ":alpha_format=premultiplied" : string.Empty;`
	`4146`	`}`
	`4147`
0	`4148`	`subFilters.Add("hwupload=derive_device=cuda");`
0	`4149`	`overlayFilters.Add($"overlay_cuda=eof_action=pass:repeatlast=0{alphaFormatOpt}");`
	`4150`	`}`
	`4151`	`}`
	`4152`	`else`
	`4153`	`{`
0	`4154`	`if (hasGraphicalSubs)`
	`4155`	`{`
0	`4156`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`4157`	`subFilters.Add(subPreProcFilters);`
0	`4158`	`overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");`
	`4159`	`}`
	`4160`	`}`
	`4161`
0	`4162`	`return (mainFilters, subFilters, overlayFilters);`
	`4163`	`}`
	`4164`
	`4165`	`/// <summary>`
	`4166`	`/// Gets the parameter of AMD AMF filter chain.`
	`4167`	`/// </summary>`
	`4168`	`/// <param name="state">Encoding state.</param>`
	`4169`	`/// <param name="options">Encoding options.</param>`
	`4170`	`/// <param name="vidEncoder">Video encoder to use.</param>`
	`4171`	`/// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>`
	`4172`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAmdVidFilterChain(`
	`4173`	`EncodingJobInfo state,`
	`4174`	`EncodingOptions options,`
	`4175`	`string vidEncoder)`
	`4176`	`{`
0	`4177`	`if (options.HardwareAccelerationType != HardwareAccelerationType.amf)`
	`4178`	`{`
0	`4179`	`return (null, null, null);`
	`4180`	`}`
	`4181`
0	`4182`	`var isWindows = OperatingSystem.IsWindows();`
0	`4183`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
0	`4184`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`4185`	`var isSwEncoder = !vidEncoder.Contains("amf", StringComparison.OrdinalIgnoreCase);`
0	`4186`	`var isAmfDx11OclSupported = isWindows && _mediaEncoder.SupportsHwaccel("d3d11va") && IsOpenclFullSupported()`
	`4187`
	`4188`	`// legacy d3d11va pipeline(copy-back)`
0	`4189`	`if ((isSwDecoder && isSwEncoder)`
0	`4190`	`\|\| !isAmfDx11OclSupported`
0	`4191`	`\|\| !_mediaEncoder.SupportsFilter("alphasrc"))`
	`4192`	`{`
0	`4193`	`return GetSwVidFilterChain(state, options, vidEncoder);`
	`4194`	`}`
	`4195`
	`4196`	`// preferred d3d11va + opencl filters + amf pipeline`
0	`4197`	`return GetAmdDx11VidFiltersPrefered(state, options, vidDecoder, vidEncoder);`
	`4198`	`}`
	`4199`
	`4200`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAmdDx11VidFiltersPref`
	`4201`	`EncodingJobInfo state,`
	`4202`	`EncodingOptions options,`
	`4203`	`string vidDecoder,`
	`4204`	`string vidEncoder)`
	`4205`	`{`
0	`4206`	`var inW = state.VideoStream?.Width;`
0	`4207`	`var inH = state.VideoStream?.Height;`
0	`4208`	`var reqW = state.BaseRequest.Width;`
0	`4209`	`var reqH = state.BaseRequest.Height;`
0	`4210`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`4211`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`4212`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`4213`
0	`4214`	`var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);`
0	`4215`	`var isAmfEncoder = vidEncoder.Contains("amf", StringComparison.OrdinalIgnoreCase);`
0	`4216`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`4217`	`var isSwEncoder = !isAmfEncoder;`
0	`4218`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
0	`4219`	`var isDxInDxOut = isD3d11vaDecoder && isAmfEncoder;`
	`4220`
0	`4221`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
0	`4222`	`var doOclTonemap = IsHwTonemapAvailable(state, options);`
	`4223`
0	`4224`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`4225`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`4226`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
0	`4227`	`var hasAssSubs = hasSubs`
0	`4228`	`&& (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)`
0	`4229`	`\|\| string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));`
0	`4230`	`var subW = state.SubtitleStream?.Width;`
0	`4231`	`var subH = state.SubtitleStream?.Height;`
	`4232`
0	`4233`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`4234`	`var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);`
0	`4235`	`var doOclTranspose = !string.IsNullOrEmpty(transposeDir)`
0	`4236`	`&& _mediaEncoder.SupportsFilterWithOption(FilterOptionType.TransposeOpenclReversal);`
0	`4237`	`var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder \|\| (isD3d11vaDecoder && doOclTranspose));`
0	`4238`	`var swpInW = swapWAndH ? inH : inW;`
0	`4239`	`var swpInH = swapWAndH ? inW : inH;`
	`4240`
	`4241`	`/* Make main filters for video stream */`
0	`4242`	`var mainFilters = new List<string>();`
	`4243`
0	`4244`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doOclTonemap));`
	`4245`
0	`4246`	`if (isSwDecoder)`
	`4247`	`{`
	`4248`	`// INPUT sw surface(memory)`
	`4249`	`// sw deint`
0	`4250`	`if (doDeintH2645)`
	`4251`	`{`
0	`4252`	`var swDeintFilter = GetSwDeinterlaceFilter(state, options);`
0	`4253`	`mainFilters.Add(swDeintFilter);`
	`4254`	`}`
	`4255`
0	`4256`	`var outFormat = doOclTonemap ? "yuv420p10le" : "yuv420p";`
0	`4257`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req`
	`4258`	`// sw scale`
0	`4259`	`mainFilters.Add(swScaleFilter);`
0	`4260`	`mainFilters.Add($"format={outFormat}");`
	`4261`
	`4262`	`// keep video at memory except ocl tonemap,`
	`4263`	`// since the overhead caused by hwupload >>> using sw filter.`
	`4264`	`// sw => hw`
0	`4265`	`if (doOclTonemap)`
	`4266`	`{`
0	`4267`	`mainFilters.Add("hwupload=derive_device=d3d11va:extra_hw_frames=24");`
0	`4268`	`mainFilters.Add("format=d3d11");`
0	`4269`	`mainFilters.Add("hwmap=derive_device=opencl:mode=read");`
	`4270`	`}`
	`4271`	`}`
	`4272`
0	`4273`	`if (isD3d11vaDecoder)`
	`4274`	`{`
	`4275`	`// INPUT d3d11 surface(vram)`
	`4276`	`// map from d3d11va to opencl via d3d11-opencl interop.`
0	`4277`	`mainFilters.Add("hwmap=derive_device=opencl:mode=read");`
	`4278`
	`4279`	`// hw deint`
0	`4280`	`if (doDeintH2645)`
	`4281`	`{`
0	`4282`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "opencl");`
0	`4283`	`mainFilters.Add(deintFilter);`
	`4284`	`}`
	`4285`
	`4286`	`// hw transpose`
0	`4287`	`if (doOclTranspose)`
	`4288`	`{`
0	`4289`	`mainFilters.Add($"transpose_opencl=dir={transposeDir}");`
	`4290`	`}`
	`4291`
0	`4292`	`var outFormat = doOclTonemap ? string.Empty : "nv12";`
0	`4293`	`var hwScaleFilter = GetHwScaleFilter("scale", "opencl", outFormat, false, swpInW, swpInH, reqW, reqH, re`
	`4294`	`// hw scale`
0	`4295`	`mainFilters.Add(hwScaleFilter);`
	`4296`	`}`
	`4297`
	`4298`	`// hw tonemap`
0	`4299`	`if (doOclTonemap)`
	`4300`	`{`
0	`4301`	`var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);`
0	`4302`	`mainFilters.Add(tonemapFilter);`
	`4303`	`}`
	`4304`
0	`4305`	`var memoryOutput = false;`
0	`4306`	`var isUploadForOclTonemap = isSwDecoder && doOclTonemap;`
0	`4307`	`if (isD3d11vaDecoder && isSwEncoder)`
	`4308`	`{`
0	`4309`	`memoryOutput = true;`
	`4310`
	`4311`	`// OUTPUT nv12 surface(memory)`
	`4312`	`// prefer hwmap to hwdownload on opencl.`
0	`4313`	`var hwTransferFilter = hasGraphicalSubs ? "hwdownload" : "hwmap=mode=read";`
0	`4314`	`mainFilters.Add(hwTransferFilter);`
0	`4315`	`mainFilters.Add("format=nv12");`
	`4316`	`}`
	`4317`
	`4318`	`// OUTPUT yuv420p surface`
0	`4319`	`if (isSwDecoder && isAmfEncoder && !isUploadForOclTonemap)`
	`4320`	`{`
0	`4321`	`memoryOutput = true;`
	`4322`	`}`
	`4323`
0	`4324`	`if (memoryOutput)`
	`4325`	`{`
	`4326`	`// text subtitles`
0	`4327`	`if (hasTextSubs)`
	`4328`	`{`
0	`4329`	`var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);`
0	`4330`	`mainFilters.Add(textSubtitlesFilter);`
	`4331`	`}`
	`4332`	`}`
	`4333`
0	`4334`	`if ((isDxInDxOut \|\| isUploadForOclTonemap) && !hasSubs)`
	`4335`	`{`
	`4336`	`// OUTPUT d3d11(nv12) surface(vram)`
	`4337`	`// reverse-mapping via d3d11-opencl interop.`
0	`4338`	`mainFilters.Add("hwmap=derive_device=d3d11va:mode=write:reverse=1");`
0	`4339`	`mainFilters.Add("format=d3d11");`
	`4340`	`}`
	`4341`
	`4342`	`/* Make sub and overlay filters for subtitle stream */`
0	`4343`	`var subFilters = new List<string>();`
0	`4344`	`var overlayFilters = new List<string>();`
0	`4345`	`if (isDxInDxOut \|\| isUploadForOclTonemap)`
	`4346`	`{`
0	`4347`	`if (hasSubs)`
	`4348`	`{`
0	`4349`	`var alphaFormatOpt = string.Empty;`
0	`4350`	`if (hasGraphicalSubs)`
	`4351`	`{`
0	`4352`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,`
0	`4353`	`subFilters.Add(subPreProcFilters);`
0	`4354`	`subFilters.Add("format=yuva420p");`
	`4355`	`}`
0	`4356`	`else if (hasTextSubs)`
	`4357`	`{`
0	`4358`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`4359`	`var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;`
	`4360`
	`4361`	`// alphasrc=s=1280x720:r=10:start=0,format=yuva420p,subtitles,hwupload`
0	`4362`	`var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH, subF`
0	`4363`	`var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);`
0	`4364`	`subFilters.Add(alphaSrcFilter);`
0	`4365`	`subFilters.Add("format=yuva420p");`
0	`4366`	`subFilters.Add(subTextSubtitlesFilter);`
	`4367`
0	`4368`	`alphaFormatOpt = _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayOpenclAlphaForma`
0	`4369`	`? ":alpha_format=premultiplied" : string.Empty;`
	`4370`	`}`
	`4371`
0	`4372`	`subFilters.Add("hwupload=derive_device=opencl");`
0	`4373`	`overlayFilters.Add($"overlay_opencl=eof_action=pass:repeatlast=0{alphaFormatOpt}");`
0	`4374`	`overlayFilters.Add("hwmap=derive_device=d3d11va:mode=write:reverse=1");`
0	`4375`	`overlayFilters.Add("format=d3d11");`
	`4376`	`}`
	`4377`	`}`
0	`4378`	`else if (memoryOutput)`
	`4379`	`{`
0	`4380`	`if (hasGraphicalSubs)`
	`4381`	`{`
0	`4382`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`4383`	`subFilters.Add(subPreProcFilters);`
0	`4384`	`overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");`
	`4385`	`}`
	`4386`	`}`
	`4387`
0	`4388`	`return (mainFilters, subFilters, overlayFilters);`
	`4389`	`}`
	`4390`
	`4391`	`/// <summary>`
	`4392`	`/// Gets the parameter of Intel QSV filter chain.`
	`4393`	`/// </summary>`
	`4394`	`/// <param name="state">Encoding state.</param>`
	`4395`	`/// <param name="options">Encoding options.</param>`
	`4396`	`/// <param name="vidEncoder">Video encoder to use.</param>`
	`4397`	`/// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>`
	`4398`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetIntelVidFilterChain(`
	`4399`	`EncodingJobInfo state,`
	`4400`	`EncodingOptions options,`
	`4401`	`string vidEncoder)`
	`4402`	`{`
0	`4403`	`if (options.HardwareAccelerationType != HardwareAccelerationType.qsv)`
	`4404`	`{`
0	`4405`	`return (null, null, null);`
	`4406`	`}`
	`4407`
0	`4408`	`var isWindows = OperatingSystem.IsWindows();`
0	`4409`	`var isLinux = OperatingSystem.IsLinux();`
0	`4410`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
0	`4411`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`4412`	`var isSwEncoder = !vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);`
0	`4413`	`var isQsvOclSupported = _mediaEncoder.SupportsHwaccel("qsv") && IsOpenclFullSupported();`
0	`4414`	`var isIntelDx11OclSupported = isWindows`
0	`4415`	`&& _mediaEncoder.SupportsHwaccel("d3d11va")`
0	`4416`	`&& isQsvOclSupported;`
0	`4417`	`var isIntelVaapiOclSupported = isLinux`
0	`4418`	`&& IsVaapiSupported(state)`
0	`4419`	`&& isQsvOclSupported;`
	`4420`
	`4421`	`// legacy qsv pipeline(copy-back)`
0	`4422`	`if ((isSwDecoder && isSwEncoder)`
0	`4423`	`\|\| (!isIntelVaapiOclSupported && !isIntelDx11OclSupported)`
0	`4424`	`\|\| !_mediaEncoder.SupportsFilter("alphasrc"))`
	`4425`	`{`
0	`4426`	`return GetSwVidFilterChain(state, options, vidEncoder);`
	`4427`	`}`
	`4428`
	`4429`	`// preferred qsv(vaapi) + opencl filters pipeline`
0	`4430`	`if (isIntelVaapiOclSupported)`
	`4431`	`{`
0	`4432`	`return GetIntelQsvVaapiVidFiltersPrefered(state, options, vidDecoder, vidEncoder);`
	`4433`	`}`
	`4434`
	`4435`	`// preferred qsv(d3d11) + opencl filters pipeline`
0	`4436`	`if (isIntelDx11OclSupported)`
	`4437`	`{`
0	`4438`	`return GetIntelQsvDx11VidFiltersPrefered(state, options, vidDecoder, vidEncoder);`
	`4439`	`}`
	`4440`
0	`4441`	`return (null, null, null);`
	`4442`	`}`
	`4443`
	`4444`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetIntelQsvDx11VidFilter`
	`4445`	`EncodingJobInfo state,`
	`4446`	`EncodingOptions options,`
	`4447`	`string vidDecoder,`
	`4448`	`string vidEncoder)`
	`4449`	`{`
0	`4450`	`var inW = state.VideoStream?.Width;`
0	`4451`	`var inH = state.VideoStream?.Height;`
0	`4452`	`var reqW = state.BaseRequest.Width;`
0	`4453`	`var reqH = state.BaseRequest.Height;`
0	`4454`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`4455`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`4456`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`4457`
0	`4458`	`var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);`
0	`4459`	`var isQsvDecoder = vidDecoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);`
0	`4460`	`var isQsvEncoder = vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);`
0	`4461`	`var isHwDecoder = isD3d11vaDecoder \|\| isQsvDecoder;`
0	`4462`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`4463`	`var isSwEncoder = !isQsvEncoder;`
0	`4464`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
0	`4465`	`var isQsvInQsvOut = isHwDecoder && isQsvEncoder;`
	`4466`
0	`4467`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
0	`4468`	`var doVppTonemap = IsIntelVppTonemapAvailable(state, options);`
0	`4469`	`var doOclTonemap = !doVppTonemap && IsHwTonemapAvailable(state, options);`
0	`4470`	`var doTonemap = doVppTonemap \|\| doOclTonemap;`
	`4471`
0	`4472`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`4473`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`4474`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
0	`4475`	`var hasAssSubs = hasSubs`
0	`4476`	`&& (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)`
0	`4477`	`\|\| string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));`
0	`4478`	`var subW = state.SubtitleStream?.Width;`
0	`4479`	`var subH = state.SubtitleStream?.Height;`
	`4480`
0	`4481`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`4482`	`var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);`
0	`4483`	`var doVppTranspose = !string.IsNullOrEmpty(transposeDir);`
0	`4484`	`var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder \|\| ((isD3d11vaDecoder \|\| isQsvDecoder) && doVppTran`
0	`4485`	`var swpInW = swapWAndH ? inH : inW;`
0	`4486`	`var swpInH = swapWAndH ? inW : inH;`
	`4487`
	`4488`	`/* Make main filters for video stream */`
0	`4489`	`var mainFilters = new List<string>();`
	`4490`
0	`4491`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doTonemap));`
	`4492`
0	`4493`	`if (isSwDecoder)`
	`4494`	`{`
	`4495`	`// INPUT sw surface(memory)`
	`4496`	`// sw deint`
0	`4497`	`if (doDeintH2645)`
	`4498`	`{`
0	`4499`	`var swDeintFilter = GetSwDeinterlaceFilter(state, options);`
0	`4500`	`mainFilters.Add(swDeintFilter);`
	`4501`	`}`
	`4502`
0	`4503`	`var outFormat = doOclTonemap ? "yuv420p10le" : (hasGraphicalSubs ? "yuv420p" : "nv12");`
0	`4504`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req`
0	`4505`	`if (isMjpegEncoder && !doOclTonemap)`
	`4506`	`{`
	`4507`	`// sw decoder + hw mjpeg encoder`
0	`4508`	`swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r`
	`4509`	`}`
	`4510`
	`4511`	`// sw scale`
0	`4512`	`mainFilters.Add(swScaleFilter);`
0	`4513`	`mainFilters.Add($"format={outFormat}");`
	`4514`
	`4515`	`// keep video at memory except ocl tonemap,`
	`4516`	`// since the overhead caused by hwupload >>> using sw filter.`
	`4517`	`// sw => hw`
0	`4518`	`if (doOclTonemap)`
	`4519`	`{`
0	`4520`	`mainFilters.Add("hwupload=derive_device=opencl");`
	`4521`	`}`
	`4522`	`}`
0	`4523`	`else if (isD3d11vaDecoder \|\| isQsvDecoder)`
	`4524`	`{`
0	`4525`	`var isRext = IsVideoStreamHevcRext(state);`
0	`4526`	`var twoPassVppTonemap = false;`
0	`4527`	`var doVppFullRangeOut = isMjpegEncoder`
0	`4528`	`&& _mediaEncoder.EncoderVersion >= _minFFmpegQsvVppOutRangeOption;`
0	`4529`	`var doVppScaleModeHq = isMjpegEncoder`
0	`4530`	`&& _mediaEncoder.EncoderVersion >= _minFFmpegQsvVppScaleModeOption;`
0	`4531`	`var doVppProcamp = false;`
0	`4532`	`var procampParams = string.Empty;`
0	`4533`	`var procampParamsString = string.Empty;`
0	`4534`	`if (doVppTonemap)`
	`4535`	`{`
0	`4536`	`if (isRext)`
	`4537`	`{`
	`4538`	`// VPP tonemap requires p010 input`
0	`4539`	`twoPassVppTonemap = true;`
	`4540`	`}`
	`4541`
0	`4542`	`if (options.VppTonemappingBrightness != 0`
0	`4543`	`&& options.VppTonemappingBrightness >= -100`
0	`4544`	`&& options.VppTonemappingBrightness <= 100)`
	`4545`	`{`
0	`4546`	`procampParamsString += ":brightness={0}";`
0	`4547`	`twoPassVppTonemap = doVppProcamp = true;`
	`4548`	`}`
	`4549`
0	`4550`	`if (options.VppTonemappingContrast > 1`
0	`4551`	`&& options.VppTonemappingContrast <= 10)`
	`4552`	`{`
0	`4553`	`procampParamsString += ":contrast={1}";`
0	`4554`	`twoPassVppTonemap = doVppProcamp = true;`
	`4555`	`}`
	`4556`
0	`4557`	`if (doVppProcamp)`
	`4558`	`{`
0	`4559`	`procampParamsString += ":procamp=1:async_depth=2";`
0	`4560`	`procampParams = string.Format(`
0	`4561`	`CultureInfo.InvariantCulture,`
0	`4562`	`procampParamsString,`
0	`4563`	`options.VppTonemappingBrightness,`
0	`4564`	`options.VppTonemappingContrast);`
	`4565`	`}`
	`4566`	`}`
	`4567`
0	`4568`	`var outFormat = doOclTonemap ? ((doVppTranspose \|\| isRext) ? "p010" : string.Empty) : "nv12";`
0	`4569`	`outFormat = twoPassVppTonemap ? "p010" : outFormat;`
	`4570`
0	`4571`	`var swapOutputWandH = doVppTranspose && swapWAndH;`
0	`4572`	`var hwScaleFilter = GetHwScaleFilter("vpp", "qsv", outFormat, swapOutputWandH, swpInW, swpInH, reqW, req`
	`4573`
	`4574`	`// d3d11va doesn't support dynamic pool size, use vpp filter ctx to relay`
	`4575`	`// to prevent encoder async and bframes from exhausting the decoder pool.`
0	`4576`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isD3d11vaDecoder)`
	`4577`	`{`
0	`4578`	`hwScaleFilter += ":passthrough=0";`
	`4579`	`}`
	`4580`
0	`4581`	`if (!string.IsNullOrEmpty(hwScaleFilter) && doVppTranspose)`
	`4582`	`{`
0	`4583`	`hwScaleFilter += $":transpose={transposeDir}";`
	`4584`	`}`
	`4585`
0	`4586`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder)`
	`4587`	`{`
0	`4588`	`hwScaleFilter += (doVppFullRangeOut && !doOclTonemap) ? ":out_range=pc" : string.Empty;`
0	`4589`	`hwScaleFilter += doVppScaleModeHq ? ":scale_mode=hq" : string.Empty;`
	`4590`	`}`
	`4591`
0	`4592`	`if (!string.IsNullOrEmpty(hwScaleFilter) && doVppTonemap)`
	`4593`	`{`
0	`4594`	`hwScaleFilter += doVppProcamp ? procampParams : (twoPassVppTonemap ? string.Empty : ":tonemap=1");`
	`4595`	`}`
	`4596`
0	`4597`	`if (isD3d11vaDecoder)`
	`4598`	`{`
0	`4599`	`if (!string.IsNullOrEmpty(hwScaleFilter) \|\| doDeintH2645)`
	`4600`	`{`
	`4601`	`// INPUT d3d11 surface(vram)`
	`4602`	`// map from d3d11va to qsv.`
0	`4603`	`mainFilters.Add("hwmap=derive_device=qsv");`
	`4604`	`}`
	`4605`	`}`
	`4606`
	`4607`	`// hw deint`
0	`4608`	`if (doDeintH2645)`
	`4609`	`{`
0	`4610`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "qsv");`
0	`4611`	`mainFilters.Add(deintFilter);`
	`4612`	`}`
	`4613`
	`4614`	`// hw transpose & scale & tonemap(w/o procamp)`
0	`4615`	`mainFilters.Add(hwScaleFilter);`
	`4616`
	`4617`	`// hw tonemap(w/ procamp)`
0	`4618`	`if (doVppTonemap && twoPassVppTonemap)`
	`4619`	`{`
0	`4620`	`mainFilters.Add("vpp_qsv=tonemap=1:format=nv12:async_depth=2");`
	`4621`	`}`
	`4622`
	`4623`	`// force bt709 just in case vpp tonemap is not triggered or using MSDK instead of VPL.`
0	`4624`	`if (doVppTonemap)`
	`4625`	`{`
0	`4626`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, false));`
	`4627`	`}`
	`4628`	`}`
	`4629`
0	`4630`	`if (doOclTonemap && isHwDecoder)`
	`4631`	`{`
	`4632`	`// map from qsv to opencl via qsv(d3d11)-opencl interop.`
0	`4633`	`mainFilters.Add("hwmap=derive_device=opencl:mode=read");`
	`4634`	`}`
	`4635`
	`4636`	`// hw tonemap`
0	`4637`	`if (doOclTonemap)`
	`4638`	`{`
0	`4639`	`var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);`
0	`4640`	`mainFilters.Add(tonemapFilter);`
	`4641`	`}`
	`4642`
0	`4643`	`var memoryOutput = false;`
0	`4644`	`var isUploadForOclTonemap = isSwDecoder && doOclTonemap;`
0	`4645`	`var isHwmapUsable = isSwEncoder && doOclTonemap;`
0	`4646`	`if ((isHwDecoder && isSwEncoder) \|\| isUploadForOclTonemap)`
	`4647`	`{`
0	`4648`	`memoryOutput = true;`
	`4649`
	`4650`	`// OUTPUT nv12 surface(memory)`
	`4651`	`// prefer hwmap to hwdownload on opencl.`
	`4652`	`// qsv hwmap is not fully implemented for the time being.`
0	`4653`	`mainFilters.Add(isHwmapUsable ? "hwmap=mode=read" : "hwdownload");`
0	`4654`	`mainFilters.Add("format=nv12");`
	`4655`	`}`
	`4656`
	`4657`	`// OUTPUT nv12 surface(memory)`
0	`4658`	`if (isSwDecoder && isQsvEncoder)`
	`4659`	`{`
0	`4660`	`memoryOutput = true;`
	`4661`	`}`
	`4662`
0	`4663`	`if (memoryOutput)`
	`4664`	`{`
	`4665`	`// text subtitles`
0	`4666`	`if (hasTextSubs)`
	`4667`	`{`
0	`4668`	`var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);`
0	`4669`	`mainFilters.Add(textSubtitlesFilter);`
	`4670`	`}`
	`4671`	`}`
	`4672`
0	`4673`	`if (isQsvInQsvOut && doOclTonemap)`
	`4674`	`{`
	`4675`	`// OUTPUT qsv(nv12) surface(vram)`
	`4676`	`// reverse-mapping via qsv(d3d11)-opencl interop.`
0	`4677`	`mainFilters.Add("hwmap=derive_device=qsv:mode=write:reverse=1");`
0	`4678`	`mainFilters.Add("format=qsv");`
	`4679`	`}`
	`4680`
	`4681`	`/* Make sub and overlay filters for subtitle stream */`
0	`4682`	`var subFilters = new List<string>();`
0	`4683`	`var overlayFilters = new List<string>();`
0	`4684`	`if (isQsvInQsvOut)`
	`4685`	`{`
0	`4686`	`if (hasSubs)`
	`4687`	`{`
0	`4688`	`if (hasGraphicalSubs)`
	`4689`	`{`
	`4690`	`// overlay_qsv can handle overlay scaling, setup a smaller height to reduce transfer overhead`
0	`4691`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,`
0	`4692`	`subFilters.Add(subPreProcFilters);`
0	`4693`	`subFilters.Add("format=bgra");`
	`4694`	`}`
0	`4695`	`else if (hasTextSubs)`
	`4696`	`{`
0	`4697`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`4698`	`var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;`
	`4699`
	`4700`	`// alphasrc=s=1280x720:r=10:start=0,format=bgra,subtitles,hwupload`
0	`4701`	`var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, 1080, subFram`
0	`4702`	`var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);`
0	`4703`	`subFilters.Add(alphaSrcFilter);`
0	`4704`	`subFilters.Add("format=bgra");`
0	`4705`	`subFilters.Add(subTextSubtitlesFilter);`
	`4706`	`}`
	`4707`
	`4708`	`// qsv requires a fixed pool size.`
	`4709`	`// default to 64 otherwise it will fail on certain iGPU.`
0	`4710`	`subFilters.Add("hwupload=derive_device=qsv:extra_hw_frames=64");`
	`4711`
0	`4712`	`var (overlayW, overlayH) = GetFixedOutputSize(swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH);`
0	`4713`	`var overlaySize = (overlayW.HasValue && overlayH.HasValue)`
0	`4714`	`? $":w={overlayW.Value}:h={overlayH.Value}"`
0	`4715`	`: string.Empty;`
0	`4716`	`var overlayQsvFilter = string.Format(`
0	`4717`	`CultureInfo.InvariantCulture,`
0	`4718`	`"overlay_qsv=eof_action=pass:repeatlast=0{0}",`
0	`4719`	`overlaySize);`
0	`4720`	`overlayFilters.Add(overlayQsvFilter);`
	`4721`	`}`
	`4722`	`}`
0	`4723`	`else if (memoryOutput)`
	`4724`	`{`
0	`4725`	`if (hasGraphicalSubs)`
	`4726`	`{`
0	`4727`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`4728`	`subFilters.Add(subPreProcFilters);`
0	`4729`	`overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");`
	`4730`	`}`
	`4731`	`}`
	`4732`
0	`4733`	`return (mainFilters, subFilters, overlayFilters);`
	`4734`	`}`
	`4735`
	`4736`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetIntelQsvVaapiVidFilte`
	`4737`	`EncodingJobInfo state,`
	`4738`	`EncodingOptions options,`
	`4739`	`string vidDecoder,`
	`4740`	`string vidEncoder)`
	`4741`	`{`
0	`4742`	`var inW = state.VideoStream?.Width;`
0	`4743`	`var inH = state.VideoStream?.Height;`
0	`4744`	`var reqW = state.BaseRequest.Width;`
0	`4745`	`var reqH = state.BaseRequest.Height;`
0	`4746`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`4747`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`4748`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`4749`
0	`4750`	`var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`4751`	`var isQsvDecoder = vidDecoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);`
0	`4752`	`var isQsvEncoder = vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);`
0	`4753`	`var isHwDecoder = isVaapiDecoder \|\| isQsvDecoder;`
0	`4754`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`4755`	`var isSwEncoder = !isQsvEncoder;`
0	`4756`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
0	`4757`	`var isQsvInQsvOut = isHwDecoder && isQsvEncoder;`
	`4758`
0	`4759`	`var doVaVppTonemap = IsIntelVppTonemapAvailable(state, options);`
0	`4760`	`var doOclTonemap = !doVaVppTonemap && IsHwTonemapAvailable(state, options);`
0	`4761`	`var doTonemap = doVaVppTonemap \|\| doOclTonemap;`
0	`4762`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
	`4763`
0	`4764`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`4765`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`4766`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
0	`4767`	`var hasAssSubs = hasSubs`
0	`4768`	`&& (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)`
0	`4769`	`\|\| string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));`
0	`4770`	`var subW = state.SubtitleStream?.Width;`
0	`4771`	`var subH = state.SubtitleStream?.Height;`
	`4772`
0	`4773`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`4774`	`var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);`
0	`4775`	`var doVppTranspose = !string.IsNullOrEmpty(transposeDir);`
0	`4776`	`var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder \|\| ((isVaapiDecoder \|\| isQsvDecoder) && doVppTransp`
0	`4777`	`var swpInW = swapWAndH ? inH : inW;`
0	`4778`	`var swpInH = swapWAndH ? inW : inH;`
	`4779`
	`4780`	`/* Make main filters for video stream */`
0	`4781`	`var mainFilters = new List<string>();`
	`4782`
0	`4783`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doTonemap));`
	`4784`
0	`4785`	`if (isSwDecoder)`
	`4786`	`{`
	`4787`	`// INPUT sw surface(memory)`
	`4788`	`// sw deint`
0	`4789`	`if (doDeintH2645)`
	`4790`	`{`
0	`4791`	`var swDeintFilter = GetSwDeinterlaceFilter(state, options);`
0	`4792`	`mainFilters.Add(swDeintFilter);`
	`4793`	`}`
	`4794`
0	`4795`	`var outFormat = doOclTonemap ? "yuv420p10le" : (hasGraphicalSubs ? "yuv420p" : "nv12");`
0	`4796`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req`
0	`4797`	`if (isMjpegEncoder && !doOclTonemap)`
	`4798`	`{`
	`4799`	`// sw decoder + hw mjpeg encoder`
0	`4800`	`swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r`
	`4801`	`}`
	`4802`
	`4803`	`// sw scale`
0	`4804`	`mainFilters.Add(swScaleFilter);`
0	`4805`	`mainFilters.Add($"format={outFormat}");`
	`4806`
	`4807`	`// keep video at memory except ocl tonemap,`
	`4808`	`// since the overhead caused by hwupload >>> using sw filter.`
	`4809`	`// sw => hw`
0	`4810`	`if (doOclTonemap)`
	`4811`	`{`
0	`4812`	`mainFilters.Add("hwupload=derive_device=opencl");`
	`4813`	`}`
	`4814`	`}`
0	`4815`	`else if (isVaapiDecoder \|\| isQsvDecoder)`
	`4816`	`{`
0	`4817`	`var hwFilterSuffix = isVaapiDecoder ? "vaapi" : "qsv";`
0	`4818`	`var isRext = IsVideoStreamHevcRext(state);`
0	`4819`	`var doVppFullRangeOut = isMjpegEncoder`
0	`4820`	`&& _mediaEncoder.EncoderVersion >= _minFFmpegQsvVppOutRangeOption;`
0	`4821`	`var doVppScaleModeHq = isMjpegEncoder`
0	`4822`	`&& _mediaEncoder.EncoderVersion >= _minFFmpegQsvVppScaleModeOption;`
	`4823`
	`4824`	`// INPUT vaapi/qsv surface(vram)`
	`4825`	`// hw deint`
0	`4826`	`if (doDeintH2645)`
	`4827`	`{`
0	`4828`	`var deintFilter = GetHwDeinterlaceFilter(state, options, hwFilterSuffix);`
0	`4829`	`mainFilters.Add(deintFilter);`
	`4830`	`}`
	`4831`
	`4832`	`// hw transpose(vaapi vpp)`
0	`4833`	`if (isVaapiDecoder && doVppTranspose)`
	`4834`	`{`
0	`4835`	`mainFilters.Add($"transpose_vaapi=dir={transposeDir}");`
	`4836`	`}`
	`4837`
0	`4838`	`var outFormat = doTonemap ? (((isQsvDecoder && doVppTranspose) \|\| isRext) ? "p010" : string.Empty) : "nv`
0	`4839`	`var swapOutputWandH = isQsvDecoder && doVppTranspose && swapWAndH;`
0	`4840`	`var hwScalePrefix = isQsvDecoder ? "vpp" : "scale";`
0	`4841`	`var hwScaleFilter = GetHwScaleFilter(hwScalePrefix, hwFilterSuffix, outFormat, swapOutputWandH, swpInW,`
	`4842`
0	`4843`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isQsvDecoder && doVppTranspose)`
	`4844`	`{`
0	`4845`	`hwScaleFilter += $":transpose={transposeDir}";`
	`4846`	`}`
	`4847`
0	`4848`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder)`
	`4849`	`{`
0	`4850`	`hwScaleFilter += ((isQsvDecoder && !doVppFullRangeOut) \|\| doOclTonemap) ? string.Empty : ":out_range`
0	`4851`	`hwScaleFilter += isQsvDecoder ? (doVppScaleModeHq ? ":scale_mode=hq" : string.Empty) : ":mode=hq";`
	`4852`	`}`
	`4853`
	`4854`	`// allocate extra pool sizes for vaapi vpp scale`
0	`4855`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isVaapiDecoder)`
	`4856`	`{`
0	`4857`	`hwScaleFilter += ":extra_hw_frames=24";`
	`4858`	`}`
	`4859`
	`4860`	`// hw transpose(qsv vpp) & scale`
0	`4861`	`mainFilters.Add(hwScaleFilter);`
	`4862`	`}`
	`4863`
	`4864`	`// vaapi vpp tonemap`
0	`4865`	`if (doVaVppTonemap && isHwDecoder)`
	`4866`	`{`
0	`4867`	`if (isQsvDecoder)`
	`4868`	`{`
	`4869`	`// map from qsv to vaapi.`
0	`4870`	`mainFilters.Add("hwmap=derive_device=vaapi");`
0	`4871`	`mainFilters.Add("format=vaapi");`
	`4872`	`}`
	`4873`
0	`4874`	`var tonemapFilter = GetHwTonemapFilter(options, "vaapi", "nv12", isMjpegEncoder);`
0	`4875`	`mainFilters.Add(tonemapFilter);`
	`4876`
0	`4877`	`if (isQsvDecoder)`
	`4878`	`{`
	`4879`	`// map from vaapi to qsv.`
0	`4880`	`mainFilters.Add("hwmap=derive_device=qsv");`
0	`4881`	`mainFilters.Add("format=qsv");`
	`4882`	`}`
	`4883`	`}`
	`4884`
0	`4885`	`if (doOclTonemap && isHwDecoder)`
	`4886`	`{`
	`4887`	`// map from qsv to opencl via qsv(vaapi)-opencl interop.`
0	`4888`	`mainFilters.Add("hwmap=derive_device=opencl:mode=read");`
	`4889`	`}`
	`4890`
	`4891`	`// ocl tonemap`
0	`4892`	`if (doOclTonemap)`
	`4893`	`{`
0	`4894`	`var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);`
0	`4895`	`mainFilters.Add(tonemapFilter);`
	`4896`	`}`
	`4897`
0	`4898`	`var memoryOutput = false;`
0	`4899`	`var isUploadForOclTonemap = isSwDecoder && doOclTonemap;`
0	`4900`	`var isHwmapUsable = isSwEncoder && (doOclTonemap \|\| isVaapiDecoder);`
0	`4901`	`if ((isHwDecoder && isSwEncoder) \|\| isUploadForOclTonemap)`
	`4902`	`{`
0	`4903`	`memoryOutput = true;`
	`4904`
	`4905`	`// OUTPUT nv12 surface(memory)`
	`4906`	`// prefer hwmap to hwdownload on opencl/vaapi.`
	`4907`	`// qsv hwmap is not fully implemented for the time being.`
0	`4908`	`mainFilters.Add(isHwmapUsable ? "hwmap=mode=read" : "hwdownload");`
0	`4909`	`mainFilters.Add("format=nv12");`
	`4910`	`}`
	`4911`
	`4912`	`// OUTPUT nv12 surface(memory)`
0	`4913`	`if (isSwDecoder && isQsvEncoder)`
	`4914`	`{`
0	`4915`	`memoryOutput = true;`
	`4916`	`}`
	`4917`
0	`4918`	`if (memoryOutput)`
	`4919`	`{`
	`4920`	`// text subtitles`
0	`4921`	`if (hasTextSubs)`
	`4922`	`{`
0	`4923`	`var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);`
0	`4924`	`mainFilters.Add(textSubtitlesFilter);`
	`4925`	`}`
	`4926`	`}`
	`4927`
0	`4928`	`if (isQsvInQsvOut)`
	`4929`	`{`
0	`4930`	`if (doOclTonemap)`
	`4931`	`{`
	`4932`	`// OUTPUT qsv(nv12) surface(vram)`
	`4933`	`// reverse-mapping via qsv(vaapi)-opencl interop.`
	`4934`	`// add extra pool size to avoid the 'cannot allocate memory' error on hevc_qsv.`
0	`4935`	`mainFilters.Add("hwmap=derive_device=qsv:mode=write:reverse=1:extra_hw_frames=16");`
0	`4936`	`mainFilters.Add("format=qsv");`
	`4937`	`}`
0	`4938`	`else if (isVaapiDecoder)`
	`4939`	`{`
0	`4940`	`mainFilters.Add("hwmap=derive_device=qsv");`
0	`4941`	`mainFilters.Add("format=qsv");`
	`4942`	`}`
	`4943`	`}`
	`4944`
	`4945`	`/* Make sub and overlay filters for subtitle stream */`
0	`4946`	`var subFilters = new List<string>();`
0	`4947`	`var overlayFilters = new List<string>();`
0	`4948`	`if (isQsvInQsvOut)`
	`4949`	`{`
0	`4950`	`if (hasSubs)`
	`4951`	`{`
0	`4952`	`if (hasGraphicalSubs)`
	`4953`	`{`
	`4954`	`// overlay_qsv can handle overlay scaling, setup a smaller height to reduce transfer overhead`
0	`4955`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,`
0	`4956`	`subFilters.Add(subPreProcFilters);`
0	`4957`	`subFilters.Add("format=bgra");`
	`4958`	`}`
0	`4959`	`else if (hasTextSubs)`
	`4960`	`{`
0	`4961`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`4962`	`var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;`
	`4963`
0	`4964`	`var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, 1080, subFram`
0	`4965`	`var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);`
0	`4966`	`subFilters.Add(alphaSrcFilter);`
0	`4967`	`subFilters.Add("format=bgra");`
0	`4968`	`subFilters.Add(subTextSubtitlesFilter);`
	`4969`	`}`
	`4970`
	`4971`	`// qsv requires a fixed pool size.`
	`4972`	`// default to 64 otherwise it will fail on certain iGPU.`
0	`4973`	`subFilters.Add("hwupload=derive_device=qsv:extra_hw_frames=64");`
	`4974`
0	`4975`	`var (overlayW, overlayH) = GetFixedOutputSize(swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH);`
0	`4976`	`var overlaySize = (overlayW.HasValue && overlayH.HasValue)`
0	`4977`	`? $":w={overlayW.Value}:h={overlayH.Value}"`
0	`4978`	`: string.Empty;`
0	`4979`	`var overlayQsvFilter = string.Format(`
0	`4980`	`CultureInfo.InvariantCulture,`
0	`4981`	`"overlay_qsv=eof_action=pass:repeatlast=0{0}",`
0	`4982`	`overlaySize);`
0	`4983`	`overlayFilters.Add(overlayQsvFilter);`
	`4984`	`}`
	`4985`	`}`
0	`4986`	`else if (memoryOutput)`
	`4987`	`{`
0	`4988`	`if (hasGraphicalSubs)`
	`4989`	`{`
0	`4990`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`4991`	`subFilters.Add(subPreProcFilters);`
0	`4992`	`overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");`
	`4993`	`}`
	`4994`	`}`
	`4995`
0	`4996`	`return (mainFilters, subFilters, overlayFilters);`
	`4997`	`}`
	`4998`
	`4999`	`/// <summary>`
	`5000`	`/// Gets the parameter of Intel/AMD VAAPI filter chain.`
	`5001`	`/// </summary>`
	`5002`	`/// <param name="state">Encoding state.</param>`
	`5003`	`/// <param name="options">Encoding options.</param>`
	`5004`	`/// <param name="vidEncoder">Video encoder to use.</param>`
	`5005`	`/// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>`
	`5006`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetVaapiVidFilterChain(`
	`5007`	`EncodingJobInfo state,`
	`5008`	`EncodingOptions options,`
	`5009`	`string vidEncoder)`
	`5010`	`{`
0	`5011`	`if (options.HardwareAccelerationType != HardwareAccelerationType.vaapi)`
	`5012`	`{`
0	`5013`	`return (null, null, null);`
	`5014`	`}`
	`5015`
0	`5016`	`var isLinux = OperatingSystem.IsLinux();`
0	`5017`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
0	`5018`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`5019`	`var isSwEncoder = !vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`5020`	`var isVaapiFullSupported = isLinux && IsVaapiSupported(state) && IsVaapiFullSupported();`
0	`5021`	`var isVaapiOclSupported = isVaapiFullSupported && IsOpenclFullSupported();`
0	`5022`	`var isVaapiVkSupported = isVaapiFullSupported && IsVulkanFullSupported();`
	`5023`
	`5024`	`// legacy vaapi pipeline(copy-back)`
0	`5025`	`if ((isSwDecoder && isSwEncoder)`
0	`5026`	`\|\| !isVaapiOclSupported`
0	`5027`	`\|\| !_mediaEncoder.SupportsFilter("alphasrc"))`
	`5028`	`{`
0	`5029`	`var swFilterChain = GetSwVidFilterChain(state, options, vidEncoder);`
	`5030`
0	`5031`	`if (!isSwEncoder)`
	`5032`	`{`
0	`5033`	`var newfilters = new List<string>();`
0	`5034`	`var noOverlay = swFilterChain.OverlayFilters.Count == 0;`
0	`5035`	`newfilters.AddRange(noOverlay ? swFilterChain.MainFilters : swFilterChain.OverlayFilters);`
0	`5036`	`newfilters.Add("hwupload=derive_device=vaapi");`
	`5037`
0	`5038`	`var mainFilters = noOverlay ? newfilters : swFilterChain.MainFilters;`
0	`5039`	`var overlayFilters = noOverlay ? swFilterChain.OverlayFilters : newfilters;`
0	`5040`	`return (mainFilters, swFilterChain.SubFilters, overlayFilters);`
	`5041`	`}`
	`5042`
0	`5043`	`return swFilterChain;`
	`5044`	`}`
	`5045`
	`5046`	`// preferred vaapi + opencl filters pipeline`
0	`5047`	`if (_mediaEncoder.IsVaapiDeviceInteliHD)`
	`5048`	`{`
	`5049`	`// Intel iHD path, with extra vpp tonemap and overlay support.`
0	`5050`	`return GetIntelVaapiFullVidFiltersPrefered(state, options, vidDecoder, vidEncoder);`
	`5051`	`}`
	`5052`
	`5053`	`// preferred vaapi + vulkan filters pipeline`
0	`5054`	`if (_mediaEncoder.IsVaapiDeviceAmd`
0	`5055`	`&& isVaapiVkSupported`
0	`5056`	`&& _mediaEncoder.IsVaapiDeviceSupportVulkanDrmInterop`
0	`5057`	`&& Environment.OSVersion.Version >= _minKernelVersionAmdVkFmtModifier)`
	`5058`	`{`
	`5059`	`// AMD radeonsi path(targeting Polaris/gfx8+), with extra vulkan tonemap and overlay support.`
0	`5060`	`return GetAmdVaapiFullVidFiltersPrefered(state, options, vidDecoder, vidEncoder);`
	`5061`	`}`
	`5062`
	`5063`	`// Intel i965 and Amd legacy driver path, only featuring scale and deinterlace support.`
0	`5064`	`return GetVaapiLimitedVidFiltersPrefered(state, options, vidDecoder, vidEncoder);`
	`5065`	`}`
	`5066`
	`5067`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetIntelVaapiFullVidFilt`
	`5068`	`EncodingJobInfo state,`
	`5069`	`EncodingOptions options,`
	`5070`	`string vidDecoder,`
	`5071`	`string vidEncoder)`
	`5072`	`{`
0	`5073`	`var inW = state.VideoStream?.Width;`
0	`5074`	`var inH = state.VideoStream?.Height;`
0	`5075`	`var reqW = state.BaseRequest.Width;`
0	`5076`	`var reqH = state.BaseRequest.Height;`
0	`5077`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`5078`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`5079`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`5080`
0	`5081`	`var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`5082`	`var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`5083`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`5084`	`var isSwEncoder = !isVaapiEncoder;`
0	`5085`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
0	`5086`	`var isVaInVaOut = isVaapiDecoder && isVaapiEncoder;`
	`5087`
0	`5088`	`var doVaVppTonemap = isVaapiDecoder && IsIntelVppTonemapAvailable(state, options);`
0	`5089`	`var doOclTonemap = !doVaVppTonemap && IsHwTonemapAvailable(state, options);`
0	`5090`	`var doTonemap = doVaVppTonemap \|\| doOclTonemap;`
0	`5091`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
	`5092`
0	`5093`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`5094`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`5095`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
0	`5096`	`var hasAssSubs = hasSubs`
0	`5097`	`&& (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)`
0	`5098`	`\|\| string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));`
0	`5099`	`var subW = state.SubtitleStream?.Width;`
0	`5100`	`var subH = state.SubtitleStream?.Height;`
	`5101`
0	`5102`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`5103`	`var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);`
0	`5104`	`var doVaVppTranspose = !string.IsNullOrEmpty(transposeDir);`
0	`5105`	`var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder \|\| (isVaapiDecoder && doVaVppTranspose));`
0	`5106`	`var swpInW = swapWAndH ? inH : inW;`
0	`5107`	`var swpInH = swapWAndH ? inW : inH;`
	`5108`
	`5109`	`/* Make main filters for video stream */`
0	`5110`	`var mainFilters = new List<string>();`
	`5111`
0	`5112`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doTonemap));`
	`5113`
0	`5114`	`if (isSwDecoder)`
	`5115`	`{`
	`5116`	`// INPUT sw surface(memory)`
	`5117`	`// sw deint`
0	`5118`	`if (doDeintH2645)`
	`5119`	`{`
0	`5120`	`var swDeintFilter = GetSwDeinterlaceFilter(state, options);`
0	`5121`	`mainFilters.Add(swDeintFilter);`
	`5122`	`}`
	`5123`
0	`5124`	`var outFormat = doOclTonemap ? "yuv420p10le" : "nv12";`
0	`5125`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req`
0	`5126`	`if (isMjpegEncoder && !doOclTonemap)`
	`5127`	`{`
	`5128`	`// sw decoder + hw mjpeg encoder`
0	`5129`	`swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r`
	`5130`	`}`
	`5131`
	`5132`	`// sw scale`
0	`5133`	`mainFilters.Add(swScaleFilter);`
0	`5134`	`mainFilters.Add($"format={outFormat}");`
	`5135`
	`5136`	`// keep video at memory except ocl tonemap,`
	`5137`	`// since the overhead caused by hwupload >>> using sw filter.`
	`5138`	`// sw => hw`
0	`5139`	`if (doOclTonemap)`
	`5140`	`{`
0	`5141`	`mainFilters.Add("hwupload=derive_device=opencl");`
	`5142`	`}`
	`5143`	`}`
0	`5144`	`else if (isVaapiDecoder)`
	`5145`	`{`
0	`5146`	`var isRext = IsVideoStreamHevcRext(state);`
	`5147`
	`5148`	`// INPUT vaapi surface(vram)`
	`5149`	`// hw deint`
0	`5150`	`if (doDeintH2645)`
	`5151`	`{`
0	`5152`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");`
0	`5153`	`mainFilters.Add(deintFilter);`
	`5154`	`}`
	`5155`
	`5156`	`// hw transpose`
0	`5157`	`if (doVaVppTranspose)`
	`5158`	`{`
0	`5159`	`mainFilters.Add($"transpose_vaapi=dir={transposeDir}");`
	`5160`	`}`
	`5161`
0	`5162`	`var outFormat = doTonemap ? (isRext ? "p010" : string.Empty) : "nv12";`
0	`5163`	`var hwScaleFilter = GetHwScaleFilter("scale", "vaapi", outFormat, false, swpInW, swpInH, reqW, reqH, req`
	`5164`
0	`5165`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder)`
	`5166`	`{`
0	`5167`	`hwScaleFilter += doOclTonemap ? string.Empty : ":out_range=pc";`
0	`5168`	`hwScaleFilter += ":mode=hq";`
	`5169`	`}`
	`5170`
	`5171`	`// allocate extra pool sizes for vaapi vpp`
0	`5172`	`if (!string.IsNullOrEmpty(hwScaleFilter))`
	`5173`	`{`
0	`5174`	`hwScaleFilter += ":extra_hw_frames=24";`
	`5175`	`}`
	`5176`
	`5177`	`// hw scale`
0	`5178`	`mainFilters.Add(hwScaleFilter);`
	`5179`	`}`
	`5180`
	`5181`	`// vaapi vpp tonemap`
0	`5182`	`if (doVaVppTonemap && isVaapiDecoder)`
	`5183`	`{`
0	`5184`	`var tonemapFilter = GetHwTonemapFilter(options, "vaapi", "nv12", isMjpegEncoder);`
0	`5185`	`mainFilters.Add(tonemapFilter);`
	`5186`	`}`
	`5187`
0	`5188`	`if (doOclTonemap && isVaapiDecoder)`
	`5189`	`{`
	`5190`	`// map from vaapi to opencl via vaapi-opencl interop(Intel only).`
0	`5191`	`mainFilters.Add("hwmap=derive_device=opencl:mode=read");`
	`5192`	`}`
	`5193`
	`5194`	`// ocl tonemap`
0	`5195`	`if (doOclTonemap)`
	`5196`	`{`
0	`5197`	`var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);`
0	`5198`	`mainFilters.Add(tonemapFilter);`
	`5199`	`}`
	`5200`
0	`5201`	`if (doOclTonemap && isVaInVaOut)`
	`5202`	`{`
	`5203`	`// OUTPUT vaapi(nv12) surface(vram)`
	`5204`	`// reverse-mapping via vaapi-opencl interop.`
0	`5205`	`mainFilters.Add("hwmap=derive_device=vaapi:mode=write:reverse=1");`
0	`5206`	`mainFilters.Add("format=vaapi");`
	`5207`	`}`
	`5208`
0	`5209`	`var memoryOutput = false;`
0	`5210`	`var isUploadForOclTonemap = isSwDecoder && doOclTonemap;`
0	`5211`	`var isHwmapNotUsable = isUploadForOclTonemap && isVaapiEncoder;`
0	`5212`	`if ((isVaapiDecoder && isSwEncoder) \|\| isUploadForOclTonemap)`
	`5213`	`{`
0	`5214`	`memoryOutput = true;`
	`5215`
	`5216`	`// OUTPUT nv12 surface(memory)`
	`5217`	`// prefer hwmap to hwdownload on opencl/vaapi.`
0	`5218`	`mainFilters.Add(isHwmapNotUsable ? "hwdownload" : "hwmap=mode=read");`
0	`5219`	`mainFilters.Add("format=nv12");`
	`5220`	`}`
	`5221`
	`5222`	`// OUTPUT nv12 surface(memory)`
0	`5223`	`if (isSwDecoder && isVaapiEncoder)`
	`5224`	`{`
0	`5225`	`memoryOutput = true;`
	`5226`	`}`
	`5227`
0	`5228`	`if (memoryOutput)`
	`5229`	`{`
	`5230`	`// text subtitles`
0	`5231`	`if (hasTextSubs)`
	`5232`	`{`
0	`5233`	`var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);`
0	`5234`	`mainFilters.Add(textSubtitlesFilter);`
	`5235`	`}`
	`5236`	`}`
	`5237`
0	`5238`	`if (memoryOutput && isVaapiEncoder)`
	`5239`	`{`
0	`5240`	`if (!hasGraphicalSubs)`
	`5241`	`{`
0	`5242`	`mainFilters.Add("hwupload_vaapi");`
	`5243`	`}`
	`5244`	`}`
	`5245`
	`5246`	`/* Make sub and overlay filters for subtitle stream */`
0	`5247`	`var subFilters = new List<string>();`
0	`5248`	`var overlayFilters = new List<string>();`
0	`5249`	`if (isVaInVaOut)`
	`5250`	`{`
0	`5251`	`if (hasSubs)`
	`5252`	`{`
0	`5253`	`if (hasGraphicalSubs)`
	`5254`	`{`
	`5255`	`// overlay_vaapi can handle overlay scaling, setup a smaller height to reduce transfer overhead`
0	`5256`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,`
0	`5257`	`subFilters.Add(subPreProcFilters);`
0	`5258`	`subFilters.Add("format=bgra");`
	`5259`	`}`
0	`5260`	`else if (hasTextSubs)`
	`5261`	`{`
0	`5262`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`5263`	`var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;`
	`5264`
0	`5265`	`var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, 1080, subFram`
0	`5266`	`var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);`
0	`5267`	`subFilters.Add(alphaSrcFilter);`
0	`5268`	`subFilters.Add("format=bgra");`
0	`5269`	`subFilters.Add(subTextSubtitlesFilter);`
	`5270`	`}`
	`5271`
0	`5272`	`subFilters.Add("hwupload=derive_device=vaapi");`
	`5273`
0	`5274`	`var (overlayW, overlayH) = GetFixedOutputSize(swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH);`
0	`5275`	`var overlaySize = (overlayW.HasValue && overlayH.HasValue)`
0	`5276`	`? $":w={overlayW.Value}:h={overlayH.Value}"`
0	`5277`	`: string.Empty;`
0	`5278`	`var overlayVaapiFilter = string.Format(`
0	`5279`	`CultureInfo.InvariantCulture,`
0	`5280`	`"overlay_vaapi=eof_action=pass:repeatlast=0{0}",`
0	`5281`	`overlaySize);`
0	`5282`	`overlayFilters.Add(overlayVaapiFilter);`
	`5283`	`}`
	`5284`	`}`
0	`5285`	`else if (memoryOutput)`
	`5286`	`{`
0	`5287`	`if (hasGraphicalSubs)`
	`5288`	`{`
0	`5289`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`5290`	`subFilters.Add(subPreProcFilters);`
0	`5291`	`overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");`
	`5292`
0	`5293`	`if (isVaapiEncoder)`
	`5294`	`{`
0	`5295`	`overlayFilters.Add("hwupload_vaapi");`
	`5296`	`}`
	`5297`	`}`
	`5298`	`}`
	`5299`
0	`5300`	`return (mainFilters, subFilters, overlayFilters);`
	`5301`	`}`
	`5302`
	`5303`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAmdVaapiFullVidFilter`
	`5304`	`EncodingJobInfo state,`
	`5305`	`EncodingOptions options,`
	`5306`	`string vidDecoder,`
	`5307`	`string vidEncoder)`
	`5308`	`{`
0	`5309`	`var inW = state.VideoStream?.Width;`
0	`5310`	`var inH = state.VideoStream?.Height;`
0	`5311`	`var reqW = state.BaseRequest.Width;`
0	`5312`	`var reqH = state.BaseRequest.Height;`
0	`5313`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`5314`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`5315`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`5316`
0	`5317`	`var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`5318`	`var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`5319`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`5320`	`var isSwEncoder = !isVaapiEncoder;`
0	`5321`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
	`5322`
0	`5323`	`var doVkTonemap = IsVulkanHwTonemapAvailable(state, options);`
0	`5324`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
	`5325`
0	`5326`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`5327`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`5328`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
0	`5329`	`var hasAssSubs = hasSubs`
0	`5330`	`&& (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)`
0	`5331`	`\|\| string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));`
	`5332`
0	`5333`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`5334`	`var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);`
0	`5335`	`var doVkTranspose = isVaapiDecoder && !string.IsNullOrEmpty(transposeDir);`
0	`5336`	`var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder \|\| (isVaapiDecoder && doVkTranspose));`
0	`5337`	`var swpInW = swapWAndH ? inH : inW;`
0	`5338`	`var swpInH = swapWAndH ? inW : inH;`
	`5339`
	`5340`	`/* Make main filters for video stream */`
0	`5341`	`var mainFilters = new List<string>();`
	`5342`
0	`5343`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doVkTonemap));`
	`5344`
0	`5345`	`if (isSwDecoder)`
	`5346`	`{`
	`5347`	`// INPUT sw surface(memory)`
	`5348`	`// sw deint`
0	`5349`	`if (doDeintH2645)`
	`5350`	`{`
0	`5351`	`var swDeintFilter = GetSwDeinterlaceFilter(state, options);`
0	`5352`	`mainFilters.Add(swDeintFilter);`
	`5353`	`}`
	`5354`
0	`5355`	`if (doVkTonemap \|\| hasSubs)`
	`5356`	`{`
	`5357`	`// sw => hw`
0	`5358`	`mainFilters.Add("hwupload=derive_device=vulkan");`
0	`5359`	`mainFilters.Add("format=vulkan");`
	`5360`	`}`
	`5361`	`else`
	`5362`	`{`
	`5363`	`// sw scale`
0	`5364`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW,`
0	`5365`	`mainFilters.Add(swScaleFilter);`
0	`5366`	`mainFilters.Add("format=nv12");`
	`5367`	`}`
	`5368`	`}`
0	`5369`	`else if (isVaapiDecoder)`
	`5370`	`{`
	`5371`	`// INPUT vaapi surface(vram)`
0	`5372`	`if (doVkTranspose \|\| doVkTonemap \|\| hasSubs)`
	`5373`	`{`
	`5374`	`// map from vaapi to vulkan/drm via interop (Polaris/gfx8+).`
0	`5375`	`if (_mediaEncoder.EncoderVersion >= _minFFmpegAlteredVaVkInterop)`
	`5376`	`{`
0	`5377`	`if (doVkTranspose \|\| !_mediaEncoder.IsVaapiDeviceSupportVulkanDrmModifier)`
	`5378`	`{`
	`5379`	`// disable the indirect va-drm-vk mapping since it's no longer reliable.`
0	`5380`	`mainFilters.Add("hwmap=derive_device=drm");`
0	`5381`	`mainFilters.Add("format=drm_prime");`
0	`5382`	`mainFilters.Add("hwmap=derive_device=vulkan");`
0	`5383`	`mainFilters.Add("format=vulkan");`
	`5384`
	`5385`	`// workaround for libplacebo using the imported vulkan frame on gfx8.`
0	`5386`	`if (!_mediaEncoder.IsVaapiDeviceSupportVulkanDrmModifier)`
	`5387`	`{`
0	`5388`	`mainFilters.Add("scale_vulkan");`
	`5389`	`}`
	`5390`	`}`
0	`5391`	`else if (doVkTonemap \|\| hasSubs)`
	`5392`	`{`
	`5393`	`// non ad-hoc libplacebo also accepts drm_prime direct input.`
0	`5394`	`mainFilters.Add("hwmap=derive_device=drm");`
0	`5395`	`mainFilters.Add("format=drm_prime");`
	`5396`	`}`
	`5397`	`}`
	`5398`	`else // legacy va-vk mapping that works only in jellyfin-ffmpeg6`
	`5399`	`{`
0	`5400`	`mainFilters.Add("hwmap=derive_device=vulkan");`
0	`5401`	`mainFilters.Add("format=vulkan");`
	`5402`	`}`
	`5403`	`}`
	`5404`	`else`
	`5405`	`{`
	`5406`	`// hw deint`
0	`5407`	`if (doDeintH2645)`
	`5408`	`{`
0	`5409`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");`
0	`5410`	`mainFilters.Add(deintFilter);`
	`5411`	`}`
	`5412`
	`5413`	`// hw scale`
0	`5414`	`var hwScaleFilter = GetHwScaleFilter("scale", "vaapi", "nv12", false, inW, inH, reqW, reqH, reqMaxW,`
	`5415`
0	`5416`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder && !doVkTonemap)`
	`5417`	`{`
0	`5418`	`hwScaleFilter += ":out_range=pc:mode=hq";`
	`5419`	`}`
	`5420`
0	`5421`	`mainFilters.Add(hwScaleFilter);`
	`5422`	`}`
	`5423`	`}`
	`5424`
	`5425`	`// vk transpose`
0	`5426`	`if (doVkTranspose)`
	`5427`	`{`
0	`5428`	`if (string.Equals(transposeDir, "reversal", StringComparison.OrdinalIgnoreCase))`
	`5429`	`{`
0	`5430`	`mainFilters.Add("flip_vulkan");`
	`5431`	`}`
	`5432`	`else`
	`5433`	`{`
0	`5434`	`mainFilters.Add($"transpose_vulkan=dir={transposeDir}");`
	`5435`	`}`
	`5436`	`}`
	`5437`
	`5438`	`// vk libplacebo`
0	`5439`	`if (doVkTonemap \|\| hasSubs)`
	`5440`	`{`
0	`5441`	`var libplaceboFilter = GetLibplaceboFilter(options, "bgra", doVkTonemap, swpInW, swpInH, reqW, reqH, req`
0	`5442`	`mainFilters.Add(libplaceboFilter);`
0	`5443`	`mainFilters.Add("format=vulkan");`
	`5444`	`}`
	`5445`
0	`5446`	`if (doVkTonemap && !hasSubs)`
	`5447`	`{`
	`5448`	`// OUTPUT vaapi(nv12) surface(vram)`
	`5449`	`// map from vulkan/drm to vaapi via interop (Polaris/gfx8+).`
0	`5450`	`mainFilters.Add("hwmap=derive_device=vaapi");`
0	`5451`	`mainFilters.Add("format=vaapi");`
	`5452`
	`5453`	`// clear the surf->meta_offset and output nv12`
0	`5454`	`mainFilters.Add("scale_vaapi=format=nv12");`
	`5455`
	`5456`	`// hw deint`
0	`5457`	`if (doDeintH2645)`
	`5458`	`{`
0	`5459`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");`
0	`5460`	`mainFilters.Add(deintFilter);`
	`5461`	`}`
	`5462`	`}`
	`5463`
0	`5464`	`if (!hasSubs)`
	`5465`	`{`
	`5466`	`// OUTPUT nv12 surface(memory)`
0	`5467`	`if (isSwEncoder && (doVkTonemap \|\| isVaapiDecoder))`
	`5468`	`{`
0	`5469`	`mainFilters.Add("hwdownload");`
0	`5470`	`mainFilters.Add("format=nv12");`
	`5471`	`}`
	`5472`
0	`5473`	`if (isSwDecoder && isVaapiEncoder && !doVkTonemap)`
	`5474`	`{`
0	`5475`	`mainFilters.Add("hwupload_vaapi");`
	`5476`	`}`
	`5477`	`}`
	`5478`
	`5479`	`/* Make sub and overlay filters for subtitle stream */`
0	`5480`	`var subFilters = new List<string>();`
0	`5481`	`var overlayFilters = new List<string>();`
0	`5482`	`if (hasSubs)`
	`5483`	`{`
0	`5484`	`if (hasGraphicalSubs)`
	`5485`	`{`
0	`5486`	`var subW = state.SubtitleStream?.Width;`
0	`5487`	`var subH = state.SubtitleStream?.Height;`
0	`5488`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`5489`	`subFilters.Add(subPreProcFilters);`
0	`5490`	`subFilters.Add("format=bgra");`
	`5491`	`}`
0	`5492`	`else if (hasTextSubs)`
	`5493`	`{`
0	`5494`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`5495`	`var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;`
	`5496`
0	`5497`	`var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH, subFrame`
0	`5498`	`var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);`
0	`5499`	`subFilters.Add(alphaSrcFilter);`
0	`5500`	`subFilters.Add("format=bgra");`
0	`5501`	`subFilters.Add(subTextSubtitlesFilter);`
	`5502`	`}`
	`5503`
0	`5504`	`subFilters.Add("hwupload=derive_device=vulkan");`
0	`5505`	`subFilters.Add("format=vulkan");`
	`5506`
0	`5507`	`overlayFilters.Add("overlay_vulkan=eof_action=pass:repeatlast=0");`
	`5508`
0	`5509`	`if (isSwEncoder)`
	`5510`	`{`
	`5511`	`// OUTPUT nv12 surface(memory)`
0	`5512`	`overlayFilters.Add("scale_vulkan=format=nv12");`
0	`5513`	`overlayFilters.Add("hwdownload");`
0	`5514`	`overlayFilters.Add("format=nv12");`
	`5515`	`}`
0	`5516`	`else if (isVaapiEncoder)`
	`5517`	`{`
	`5518`	`// OUTPUT vaapi(nv12) surface(vram)`
	`5519`	`// map from vulkan/drm to vaapi via interop (Polaris/gfx8+).`
0	`5520`	`overlayFilters.Add("hwmap=derive_device=vaapi");`
0	`5521`	`overlayFilters.Add("format=vaapi");`
	`5522`
	`5523`	`// clear the surf->meta_offset and output nv12`
0	`5524`	`overlayFilters.Add("scale_vaapi=format=nv12");`
	`5525`
	`5526`	`// hw deint`
0	`5527`	`if (doDeintH2645)`
	`5528`	`{`
0	`5529`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");`
0	`5530`	`overlayFilters.Add(deintFilter);`
	`5531`	`}`
	`5532`	`}`
	`5533`	`}`
	`5534`
0	`5535`	`return (mainFilters, subFilters, overlayFilters);`
	`5536`	`}`
	`5537`
	`5538`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetVaapiLimitedVidFilter`
	`5539`	`EncodingJobInfo state,`
	`5540`	`EncodingOptions options,`
	`5541`	`string vidDecoder,`
	`5542`	`string vidEncoder)`
	`5543`	`{`
0	`5544`	`var inW = state.VideoStream?.Width;`
0	`5545`	`var inH = state.VideoStream?.Height;`
0	`5546`	`var reqW = state.BaseRequest.Width;`
0	`5547`	`var reqH = state.BaseRequest.Height;`
0	`5548`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`5549`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`5550`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`5551`
0	`5552`	`var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`5553`	`var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);`
0	`5554`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`5555`	`var isSwEncoder = !isVaapiEncoder;`
0	`5556`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
0	`5557`	`var isVaInVaOut = isVaapiDecoder && isVaapiEncoder;`
0	`5558`	`var isi965Driver = _mediaEncoder.IsVaapiDeviceInteli965;`
0	`5559`	`var isAmdDriver = _mediaEncoder.IsVaapiDeviceAmd;`
	`5560`
0	`5561`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
0	`5562`	`var doOclTonemap = IsHwTonemapAvailable(state, options);`
	`5563`
0	`5564`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`5565`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`5566`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
	`5567`
0	`5568`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`5569`	`var swapWAndH = Math.Abs(rotation) == 90 && isSwDecoder;`
0	`5570`	`var swpInW = swapWAndH ? inH : inW;`
0	`5571`	`var swpInH = swapWAndH ? inW : inH;`
	`5572`
	`5573`	`/* Make main filters for video stream */`
0	`5574`	`var mainFilters = new List<string>();`
	`5575`
0	`5576`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doOclTonemap));`
	`5577`
0	`5578`	`var outFormat = string.Empty;`
0	`5579`	`if (isSwDecoder)`
	`5580`	`{`
	`5581`	`// INPUT sw surface(memory)`
	`5582`	`// sw deint`
0	`5583`	`if (doDeintH2645)`
	`5584`	`{`
0	`5585`	`var swDeintFilter = GetSwDeinterlaceFilter(state, options);`
0	`5586`	`mainFilters.Add(swDeintFilter);`
	`5587`	`}`
	`5588`
0	`5589`	`outFormat = doOclTonemap ? "yuv420p10le" : "nv12";`
0	`5590`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req`
0	`5591`	`if (isMjpegEncoder && !doOclTonemap)`
	`5592`	`{`
	`5593`	`// sw decoder + hw mjpeg encoder`
0	`5594`	`swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r`
	`5595`	`}`
	`5596`
	`5597`	`// sw scale`
0	`5598`	`mainFilters.Add(swScaleFilter);`
0	`5599`	`mainFilters.Add("format=" + outFormat);`
	`5600`
	`5601`	`// keep video at memory except ocl tonemap,`
	`5602`	`// since the overhead caused by hwupload >>> using sw filter.`
	`5603`	`// sw => hw`
0	`5604`	`if (doOclTonemap)`
	`5605`	`{`
0	`5606`	`mainFilters.Add("hwupload=derive_device=opencl");`
	`5607`	`}`
	`5608`	`}`
0	`5609`	`else if (isVaapiDecoder)`
	`5610`	`{`
	`5611`	`// INPUT vaapi surface(vram)`
	`5612`	`// hw deint`
0	`5613`	`if (doDeintH2645)`
	`5614`	`{`
0	`5615`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");`
0	`5616`	`mainFilters.Add(deintFilter);`
	`5617`	`}`
	`5618`
0	`5619`	`outFormat = doOclTonemap ? string.Empty : "nv12";`
0	`5620`	`var hwScaleFilter = GetHwScaleFilter("scale", "vaapi", outFormat, false, inW, inH, reqW, reqH, reqMaxW,`
	`5621`
0	`5622`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder)`
	`5623`	`{`
0	`5624`	`hwScaleFilter += doOclTonemap ? string.Empty : ":out_range=pc";`
0	`5625`	`hwScaleFilter += ":mode=hq";`
	`5626`	`}`
	`5627`
	`5628`	`// allocate extra pool sizes for vaapi vpp`
0	`5629`	`if (!string.IsNullOrEmpty(hwScaleFilter))`
	`5630`	`{`
0	`5631`	`hwScaleFilter += ":extra_hw_frames=24";`
	`5632`	`}`
	`5633`
	`5634`	`// hw scale`
0	`5635`	`mainFilters.Add(hwScaleFilter);`
	`5636`	`}`
	`5637`
0	`5638`	`if (doOclTonemap && isVaapiDecoder)`
	`5639`	`{`
0	`5640`	`if (isi965Driver)`
	`5641`	`{`
	`5642`	`// map from vaapi to opencl via vaapi-opencl interop(Intel only).`
0	`5643`	`mainFilters.Add("hwmap=derive_device=opencl");`
	`5644`	`}`
	`5645`	`else`
	`5646`	`{`
0	`5647`	`mainFilters.Add("hwdownload");`
0	`5648`	`mainFilters.Add("format=p010le");`
0	`5649`	`mainFilters.Add("hwupload=derive_device=opencl");`
	`5650`	`}`
	`5651`	`}`
	`5652`
	`5653`	`// ocl tonemap`
0	`5654`	`if (doOclTonemap)`
	`5655`	`{`
0	`5656`	`var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);`
0	`5657`	`mainFilters.Add(tonemapFilter);`
	`5658`	`}`
	`5659`
0	`5660`	`if (doOclTonemap && isVaInVaOut)`
	`5661`	`{`
0	`5662`	`if (isi965Driver)`
	`5663`	`{`
	`5664`	`// OUTPUT vaapi(nv12) surface(vram)`
	`5665`	`// reverse-mapping via vaapi-opencl interop.`
0	`5666`	`mainFilters.Add("hwmap=derive_device=vaapi:reverse=1");`
0	`5667`	`mainFilters.Add("format=vaapi");`
	`5668`	`}`
	`5669`	`}`
	`5670`
0	`5671`	`var memoryOutput = false;`
0	`5672`	`var isUploadForOclTonemap = doOclTonemap && (isSwDecoder \|\| (isVaapiDecoder && !isi965Driver));`
0	`5673`	`var isHwmapNotUsable = hasGraphicalSubs \|\| isUploadForOclTonemap;`
0	`5674`	`var isHwmapForSubs = hasSubs && isVaapiDecoder;`
0	`5675`	`var isHwUnmapForTextSubs = hasTextSubs && isVaInVaOut && !isUploadForOclTonemap;`
0	`5676`	`if ((isVaapiDecoder && isSwEncoder) \|\| isUploadForOclTonemap \|\| isHwmapForSubs)`
	`5677`	`{`
0	`5678`	`memoryOutput = true;`
	`5679`
	`5680`	`// OUTPUT nv12 surface(memory)`
	`5681`	`// prefer hwmap to hwdownload on opencl/vaapi.`
0	`5682`	`mainFilters.Add(isHwmapNotUsable ? "hwdownload" : "hwmap");`
0	`5683`	`mainFilters.Add("format=nv12");`
	`5684`	`}`
	`5685`
	`5686`	`// OUTPUT nv12 surface(memory)`
0	`5687`	`if (isSwDecoder && isVaapiEncoder)`
	`5688`	`{`
0	`5689`	`memoryOutput = true;`
	`5690`	`}`
	`5691`
0	`5692`	`if (memoryOutput)`
	`5693`	`{`
	`5694`	`// text subtitles`
0	`5695`	`if (hasTextSubs)`
	`5696`	`{`
0	`5697`	`var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);`
0	`5698`	`mainFilters.Add(textSubtitlesFilter);`
	`5699`	`}`
	`5700`	`}`
	`5701`
0	`5702`	`if (isHwUnmapForTextSubs)`
	`5703`	`{`
0	`5704`	`mainFilters.Add("hwmap");`
0	`5705`	`mainFilters.Add("format=vaapi");`
	`5706`	`}`
0	`5707`	`else if (memoryOutput && isVaapiEncoder)`
	`5708`	`{`
0	`5709`	`if (!hasGraphicalSubs)`
	`5710`	`{`
0	`5711`	`mainFilters.Add("hwupload_vaapi");`
	`5712`	`}`
	`5713`	`}`
	`5714`
	`5715`	`/* Make sub and overlay filters for subtitle stream */`
0	`5716`	`var subFilters = new List<string>();`
0	`5717`	`var overlayFilters = new List<string>();`
0	`5718`	`if (memoryOutput)`
	`5719`	`{`
0	`5720`	`if (hasGraphicalSubs)`
	`5721`	`{`
0	`5722`	`var subW = state.SubtitleStream?.Width;`
0	`5723`	`var subH = state.SubtitleStream?.Height;`
0	`5724`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`5725`	`subFilters.Add(subPreProcFilters);`
0	`5726`	`overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");`
	`5727`
0	`5728`	`if (isVaapiEncoder)`
	`5729`	`{`
0	`5730`	`overlayFilters.Add("hwupload_vaapi");`
	`5731`	`}`
	`5732`	`}`
	`5733`	`}`
	`5734`
0	`5735`	`return (mainFilters, subFilters, overlayFilters);`
	`5736`	`}`
	`5737`
	`5738`	`/// <summary>`
	`5739`	`/// Gets the parameter of Apple VideoToolBox filter chain.`
	`5740`	`/// </summary>`
	`5741`	`/// <param name="state">Encoding state.</param>`
	`5742`	`/// <param name="options">Encoding options.</param>`
	`5743`	`/// <param name="vidEncoder">Video encoder to use.</param>`
	`5744`	`/// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>`
	`5745`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAppleVidFilterChain(`
	`5746`	`EncodingJobInfo state,`
	`5747`	`EncodingOptions options,`
	`5748`	`string vidEncoder)`
	`5749`	`{`
0	`5750`	`if (options.HardwareAccelerationType != HardwareAccelerationType.videotoolbox)`
	`5751`	`{`
0	`5752`	`return (null, null, null);`
	`5753`	`}`
	`5754`
	`5755`	`// ReSharper disable once InconsistentNaming`
0	`5756`	`var isMacOS = OperatingSystem.IsMacOS();`
0	`5757`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
0	`5758`	`var isVtDecoder = vidDecoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);`
0	`5759`	`var isVtEncoder = vidEncoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);`
0	`5760`	`var isVtFullSupported = isMacOS && IsVideoToolboxFullSupported();`
	`5761`
	`5762`	`// legacy videotoolbox pipeline (disable hw filters)`
0	`5763`	`if (!(isVtEncoder \|\| isVtDecoder)`
0	`5764`	`\|\| !isVtFullSupported`
0	`5765`	`\|\| !_mediaEncoder.SupportsFilter("alphasrc"))`
	`5766`	`{`
0	`5767`	`return GetSwVidFilterChain(state, options, vidEncoder);`
	`5768`	`}`
	`5769`
	`5770`	`// preferred videotoolbox + metal filters pipeline`
0	`5771`	`return GetAppleVidFiltersPreferred(state, options, vidDecoder, vidEncoder);`
	`5772`	`}`
	`5773`
	`5774`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAppleVidFiltersPrefer`
	`5775`	`EncodingJobInfo state,`
	`5776`	`EncodingOptions options,`
	`5777`	`string vidDecoder,`
	`5778`	`string vidEncoder)`
	`5779`	`{`
0	`5780`	`var isVtEncoder = vidEncoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);`
0	`5781`	`var isVtDecoder = vidDecoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);`
0	`5782`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
	`5783`
0	`5784`	`var inW = state.VideoStream?.Width;`
0	`5785`	`var inH = state.VideoStream?.Height;`
0	`5786`	`var reqW = state.BaseRequest.Width;`
0	`5787`	`var reqH = state.BaseRequest.Height;`
0	`5788`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`5789`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`5790`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`5791`
0	`5792`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
0	`5793`	`var doVtTonemap = IsVideoToolboxTonemapAvailable(state, options);`
0	`5794`	`var doMetalTonemap = !doVtTonemap && IsHwTonemapAvailable(state, options);`
0	`5795`	`var usingHwSurface = isVtDecoder && (_mediaEncoder.EncoderVersion >= _minFFmpegWorkingVtHwSurface);`
	`5796`
0	`5797`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`5798`	`var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);`
0	`5799`	`var doVtTranspose = !string.IsNullOrEmpty(transposeDir) && _mediaEncoder.SupportsFilter("transpose_vt");`
0	`5800`	`var swapWAndH = Math.Abs(rotation) == 90 && doVtTranspose;`
0	`5801`	`var swpInW = swapWAndH ? inH : inW;`
0	`5802`	`var swpInH = swapWAndH ? inW : inH;`
	`5803`
0	`5804`	`var scaleFormat = string.Empty;`
	`5805`	`// Use P010 for Metal tone mapping, otherwise force an 8bit output.`
0	`5806`	`if (!string.Equals(state.VideoStream.PixelFormat, "yuv420p", StringComparison.OrdinalIgnoreCase))`
	`5807`	`{`
0	`5808`	`if (doMetalTonemap)`
	`5809`	`{`
0	`5810`	`if (!string.Equals(state.VideoStream.PixelFormat, "yuv420p10le", StringComparison.OrdinalIgnoreCase)`
	`5811`	`{`
0	`5812`	`scaleFormat = "p010le";`
	`5813`	`}`
	`5814`	`}`
	`5815`	`else`
	`5816`	`{`
0	`5817`	`scaleFormat = "nv12";`
	`5818`	`}`
	`5819`	`}`
	`5820`
0	`5821`	`var hwScaleFilter = GetHwScaleFilter("scale", "vt", scaleFormat, false, swpInW, swpInH, reqW, reqH, reqMaxW,`
	`5822`
0	`5823`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`5824`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`5825`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
0	`5826`	`var hasAssSubs = hasSubs`
0	`5827`	`&& (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)`
0	`5828`	`\|\| string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));`
	`5829`
	`5830`	`/* Make main filters for video stream */`
0	`5831`	`var mainFilters = new List<string>();`
	`5832`
	`5833`	`// hw deint`
0	`5834`	`if (doDeintH2645)`
	`5835`	`{`
0	`5836`	`var deintFilter = GetHwDeinterlaceFilter(state, options, "videotoolbox");`
0	`5837`	`mainFilters.Add(deintFilter);`
	`5838`	`}`
	`5839`
	`5840`	`// hw transpose`
0	`5841`	`if (doVtTranspose)`
	`5842`	`{`
0	`5843`	`mainFilters.Add($"transpose_vt=dir={transposeDir}");`
	`5844`	`}`
	`5845`
0	`5846`	`if (doVtTonemap)`
	`5847`	`{`
	`5848`	`const string VtTonemapArgs = "color_matrix=bt709:color_primaries=bt709:color_transfer=bt709";`
	`5849`
	`5850`	`// scale_vt can handle scaling & tonemapping in one shot, just like vpp_qsv.`
0	`5851`	`hwScaleFilter = string.IsNullOrEmpty(hwScaleFilter)`
0	`5852`	`? "scale_vt=" + VtTonemapArgs`
0	`5853`	`: hwScaleFilter + ":" + VtTonemapArgs;`
	`5854`	`}`
	`5855`
	`5856`	`// hw scale & vt tonemap`
0	`5857`	`mainFilters.Add(hwScaleFilter);`
	`5858`
	`5859`	`// Metal tonemap`
0	`5860`	`if (doMetalTonemap)`
	`5861`	`{`
0	`5862`	`var tonemapFilter = GetHwTonemapFilter(options, "videotoolbox", "nv12", isMjpegEncoder);`
0	`5863`	`mainFilters.Add(tonemapFilter);`
	`5864`	`}`
	`5865`
	`5866`	`/* Make sub and overlay filters for subtitle stream */`
0	`5867`	`var subFilters = new List<string>();`
0	`5868`	`var overlayFilters = new List<string>();`
	`5869`
0	`5870`	`if (hasSubs)`
	`5871`	`{`
0	`5872`	`if (hasGraphicalSubs)`
	`5873`	`{`
0	`5874`	`var subW = state.SubtitleStream?.Width;`
0	`5875`	`var subH = state.SubtitleStream?.Height;`
0	`5876`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`5877`	`subFilters.Add(subPreProcFilters);`
0	`5878`	`subFilters.Add("format=bgra");`
	`5879`	`}`
0	`5880`	`else if (hasTextSubs)`
	`5881`	`{`
0	`5882`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`5883`	`var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;`
	`5884`
0	`5885`	`var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH, subFrame`
0	`5886`	`var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);`
0	`5887`	`subFilters.Add(alphaSrcFilter);`
0	`5888`	`subFilters.Add("format=bgra");`
0	`5889`	`subFilters.Add(subTextSubtitlesFilter);`
	`5890`	`}`
	`5891`
0	`5892`	`subFilters.Add("hwupload");`
0	`5893`	`overlayFilters.Add("overlay_videotoolbox=eof_action=pass:repeatlast=0");`
	`5894`	`}`
	`5895`
0	`5896`	`if (usingHwSurface)`
	`5897`	`{`
0	`5898`	`if (!isVtEncoder)`
	`5899`	`{`
0	`5900`	`mainFilters.Add("hwdownload");`
0	`5901`	`mainFilters.Add("format=nv12");`
	`5902`	`}`
	`5903`
0	`5904`	`return (mainFilters, subFilters, overlayFilters);`
	`5905`	`}`
	`5906`
	`5907`	`// For old jellyfin-ffmpeg that has broken hwsurface, add a hwupload`
0	`5908`	`var needFiltering = mainFilters.Any(f => !string.IsNullOrEmpty(f)) \|\|`
0	`5909`	`subFilters.Any(f => !string.IsNullOrEmpty(f)) \|\|`
0	`5910`	`overlayFilters.Any(f => !string.IsNullOrEmpty(f));`
0	`5911`	`if (needFiltering)`
	`5912`	`{`
	`5913`	`// INPUT videotoolbox/memory surface(vram/uma)`
	`5914`	`// this will pass-through automatically if in/out format matches.`
0	`5915`	`mainFilters.Insert(0, "hwupload");`
0	`5916`	`mainFilters.Insert(0, "format=nv12\|p010le\|videotoolbox_vld");`
	`5917`
0	`5918`	`if (!isVtEncoder)`
	`5919`	`{`
0	`5920`	`mainFilters.Add("hwdownload");`
0	`5921`	`mainFilters.Add("format=nv12");`
	`5922`	`}`
	`5923`	`}`
	`5924`
0	`5925`	`return (mainFilters, subFilters, overlayFilters);`
	`5926`	`}`
	`5927`
	`5928`	`/// <summary>`
	`5929`	`/// Gets the parameter of Rockchip RKMPP/RKRGA filter chain.`
	`5930`	`/// </summary>`
	`5931`	`/// <param name="state">Encoding state.</param>`
	`5932`	`/// <param name="options">Encoding options.</param>`
	`5933`	`/// <param name="vidEncoder">Video encoder to use.</param>`
	`5934`	`/// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>`
	`5935`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetRkmppVidFilterChain(`
	`5936`	`EncodingJobInfo state,`
	`5937`	`EncodingOptions options,`
	`5938`	`string vidEncoder)`
	`5939`	`{`
0	`5940`	`if (options.HardwareAccelerationType != HardwareAccelerationType.rkmpp)`
	`5941`	`{`
0	`5942`	`return (null, null, null);`
	`5943`	`}`
	`5944`
0	`5945`	`var isLinux = OperatingSystem.IsLinux();`
0	`5946`	`var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;`
0	`5947`	`var isSwDecoder = string.IsNullOrEmpty(vidDecoder);`
0	`5948`	`var isSwEncoder = !vidEncoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);`
0	`5949`	`var isRkmppOclSupported = isLinux && IsRkmppFullSupported() && IsOpenclFullSupported();`
	`5950`
0	`5951`	`if ((isSwDecoder && isSwEncoder)`
0	`5952`	`\|\| !isRkmppOclSupported`
0	`5953`	`\|\| !_mediaEncoder.SupportsFilter("alphasrc"))`
	`5954`	`{`
0	`5955`	`return GetSwVidFilterChain(state, options, vidEncoder);`
	`5956`	`}`
	`5957`
	`5958`	`// preferred rkmpp + rkrga + opencl filters pipeline`
0	`5959`	`if (isRkmppOclSupported)`
	`5960`	`{`
0	`5961`	`return GetRkmppVidFiltersPrefered(state, options, vidDecoder, vidEncoder);`
	`5962`	`}`
	`5963`
0	`5964`	`return (null, null, null);`
	`5965`	`}`
	`5966`
	`5967`	`public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetRkmppVidFiltersPrefer`
	`5968`	`EncodingJobInfo state,`
	`5969`	`EncodingOptions options,`
	`5970`	`string vidDecoder,`
	`5971`	`string vidEncoder)`
	`5972`	`{`
0	`5973`	`var inW = state.VideoStream?.Width;`
0	`5974`	`var inH = state.VideoStream?.Height;`
0	`5975`	`var reqW = state.BaseRequest.Width;`
0	`5976`	`var reqH = state.BaseRequest.Height;`
0	`5977`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`5978`	`var reqMaxH = state.BaseRequest.MaxHeight;`
0	`5979`	`var threeDFormat = state.MediaSource.Video3DFormat;`
	`5980`
0	`5981`	`var isRkmppDecoder = vidDecoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);`
0	`5982`	`var isRkmppEncoder = vidEncoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);`
0	`5983`	`var isSwDecoder = !isRkmppDecoder;`
0	`5984`	`var isSwEncoder = !isRkmppEncoder;`
0	`5985`	`var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);`
0	`5986`	`var isDrmInDrmOut = isRkmppDecoder && isRkmppEncoder;`
0	`5987`	`var isEncoderSupportAfbc = isRkmppEncoder`
0	`5988`	`&& (vidEncoder.Contains("h264", StringComparison.OrdinalIgnoreCase)`
0	`5989`	`\|\| vidEncoder.Contains("hevc", StringComparison.OrdinalIgnoreCase));`
	`5990`
0	`5991`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
0	`5992`	`var doOclTonemap = IsHwTonemapAvailable(state, options);`
	`5993`
0	`5994`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`5995`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`5996`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
0	`5997`	`var hasAssSubs = hasSubs`
0	`5998`	`&& (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)`
0	`5999`	`\|\| string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));`
0	`6000`	`var subW = state.SubtitleStream?.Width;`
0	`6001`	`var subH = state.SubtitleStream?.Height;`
	`6002`
0	`6003`	`var rotation = state.VideoStream?.Rotation ?? 0;`
0	`6004`	`var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);`
0	`6005`	`var doRkVppTranspose = !string.IsNullOrEmpty(transposeDir);`
0	`6006`	`var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder \|\| (isRkmppDecoder && doRkVppTranspose));`
0	`6007`	`var swpInW = swapWAndH ? inH : inW;`
0	`6008`	`var swpInH = swapWAndH ? inW : inH;`
	`6009`
	`6010`	`/* Make main filters for video stream */`
0	`6011`	`var mainFilters = new List<string>();`
	`6012`
0	`6013`	`mainFilters.Add(GetOverwriteColorPropertiesParam(state, doOclTonemap));`
	`6014`
0	`6015`	`if (isSwDecoder)`
	`6016`	`{`
	`6017`	`// INPUT sw surface(memory)`
	`6018`	`// sw deint`
0	`6019`	`if (doDeintH2645)`
	`6020`	`{`
0	`6021`	`var swDeintFilter = GetSwDeinterlaceFilter(state, options);`
0	`6022`	`mainFilters.Add(swDeintFilter);`
	`6023`	`}`
	`6024`
0	`6025`	`var outFormat = doOclTonemap ? "yuv420p10le" : (hasGraphicalSubs ? "yuv420p" : "nv12");`
0	`6026`	`var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req`
0	`6027`	`if (isMjpegEncoder && !doOclTonemap)`
	`6028`	`{`
	`6029`	`// sw decoder + hw mjpeg encoder`
0	`6030`	`swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r`
	`6031`	`}`
	`6032`
0	`6033`	`if (!string.IsNullOrEmpty(swScaleFilter))`
	`6034`	`{`
0	`6035`	`swScaleFilter += ":flags=fast_bilinear";`
	`6036`	`}`
	`6037`
	`6038`	`// sw scale`
0	`6039`	`mainFilters.Add(swScaleFilter);`
0	`6040`	`mainFilters.Add($"format={outFormat}");`
	`6041`
	`6042`	`// keep video at memory except ocl tonemap,`
	`6043`	`// since the overhead caused by hwupload >>> using sw filter.`
	`6044`	`// sw => hw`
0	`6045`	`if (doOclTonemap)`
	`6046`	`{`
0	`6047`	`mainFilters.Add("hwupload=derive_device=opencl");`
	`6048`	`}`
	`6049`	`}`
0	`6050`	`else if (isRkmppDecoder)`
	`6051`	`{`
	`6052`	`// INPUT rkmpp/drm surface(gem/dma-heap)`
	`6053`
0	`6054`	`var isFullAfbcPipeline = isEncoderSupportAfbc && isDrmInDrmOut && !doOclTonemap;`
0	`6055`	`var swapOutputWandH = doRkVppTranspose && swapWAndH;`
0	`6056`	`var outFormat = doOclTonemap ? "p010" : "nv12";`
0	`6057`	`var hwScaleFilter = GetHwScaleFilter("vpp", "rkrga", outFormat, swapOutputWandH, swpInW, swpInH, reqW, r`
0	`6058`	`var doScaling = !string.IsNullOrEmpty(GetHwScaleFilter("vpp", "rkrga", string.Empty, swapOutputWandH, sw`
	`6059`
0	`6060`	`if (!hasSubs`
0	`6061`	`\|\| doRkVppTranspose`
0	`6062`	`\|\| !isFullAfbcPipeline`
0	`6063`	`\|\| doScaling)`
	`6064`	`{`
0	`6065`	`var isScaleRatioSupported = IsScaleRatioSupported(inW, inH, reqW, reqH, reqMaxW, reqMaxH, 8.0f);`
	`6066`
	`6067`	`// RGA3 hardware only support (1/8 ~ 8) scaling in each blit operation,`
	`6068`	`// but in Trickplay there's a case: (3840/320 == 12), enable 2pass for it`
0	`6069`	`if (doScaling && !isScaleRatioSupported)`
	`6070`	`{`
	`6071`	`// Vendor provided BSP kernel has an RGA driver bug that causes the output to be corrupted for P`
	`6072`	`// Use NV15 instead of P010 to avoid the issue.`
	`6073`	`// SDR inputs are using BGRA formats already which is not affected.`
0	`6074`	`var intermediateFormat = doOclTonemap ? "nv15" : (isMjpegEncoder ? "bgra" : outFormat);`
0	`6075`	`var hwScaleFilterFirstPass = $"scale_rkrga=w=iw/7.9:h=ih/7.9:format={intermediateFormat}:force_o`
0	`6076`	`mainFilters.Add(hwScaleFilterFirstPass);`
	`6077`	`}`
	`6078`
	`6079`	`// The RKMPP MJPEG encoder on some newer chip models no longer supports RGB input.`
	`6080`	`// Use 2pass here to enable RGA output of full-range YUV in the 2nd pass.`
0	`6081`	`if (isMjpegEncoder && !doOclTonemap && ((doScaling && isScaleRatioSupported) \|\| !doScaling))`
	`6082`	`{`
0	`6083`	`var hwScaleFilterFirstPass = "vpp_rkrga=format=bgra:afbc=1";`
0	`6084`	`mainFilters.Add(hwScaleFilterFirstPass);`
	`6085`	`}`
	`6086`
0	`6087`	`if (!string.IsNullOrEmpty(hwScaleFilter) && doRkVppTranspose)`
	`6088`	`{`
0	`6089`	`hwScaleFilter += $":transpose={transposeDir}";`
	`6090`	`}`
	`6091`
	`6092`	`// try enabling AFBC to save DDR bandwidth`
0	`6093`	`if (!string.IsNullOrEmpty(hwScaleFilter) && isFullAfbcPipeline)`
	`6094`	`{`
0	`6095`	`hwScaleFilter += ":afbc=1";`
	`6096`	`}`
	`6097`
	`6098`	`// hw transpose & scale`
0	`6099`	`mainFilters.Add(hwScaleFilter);`
	`6100`	`}`
	`6101`	`}`
	`6102`
0	`6103`	`if (doOclTonemap && isRkmppDecoder)`
	`6104`	`{`
	`6105`	`// map from rkmpp/drm to opencl via drm-opencl interop.`
0	`6106`	`mainFilters.Add("hwmap=derive_device=opencl");`
	`6107`	`}`
	`6108`
	`6109`	`// ocl tonemap`
0	`6110`	`if (doOclTonemap)`
	`6111`	`{`
0	`6112`	`var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);`
0	`6113`	`mainFilters.Add(tonemapFilter);`
	`6114`	`}`
	`6115`
0	`6116`	`var memoryOutput = false;`
0	`6117`	`var isUploadForOclTonemap = isSwDecoder && doOclTonemap;`
0	`6118`	`if ((isRkmppDecoder && isSwEncoder) \|\| isUploadForOclTonemap)`
	`6119`	`{`
0	`6120`	`memoryOutput = true;`
	`6121`
	`6122`	`// OUTPUT nv12 surface(memory)`
0	`6123`	`mainFilters.Add("hwdownload");`
0	`6124`	`mainFilters.Add("format=nv12");`
	`6125`	`}`
	`6126`
	`6127`	`// OUTPUT nv12 surface(memory)`
0	`6128`	`if (isSwDecoder && isRkmppEncoder)`
	`6129`	`{`
0	`6130`	`memoryOutput = true;`
	`6131`	`}`
	`6132`
0	`6133`	`if (memoryOutput)`
	`6134`	`{`
	`6135`	`// text subtitles`
0	`6136`	`if (hasTextSubs)`
	`6137`	`{`
0	`6138`	`var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);`
0	`6139`	`mainFilters.Add(textSubtitlesFilter);`
	`6140`	`}`
	`6141`	`}`
	`6142`
0	`6143`	`if (isDrmInDrmOut)`
	`6144`	`{`
0	`6145`	`if (doOclTonemap)`
	`6146`	`{`
	`6147`	`// OUTPUT drm(nv12) surface(gem/dma-heap)`
	`6148`	`// reverse-mapping via drm-opencl interop.`
0	`6149`	`mainFilters.Add("hwmap=derive_device=rkmpp:reverse=1");`
0	`6150`	`mainFilters.Add("format=drm_prime");`
	`6151`	`}`
	`6152`	`}`
	`6153`
	`6154`	`/* Make sub and overlay filters for subtitle stream */`
0	`6155`	`var subFilters = new List<string>();`
0	`6156`	`var overlayFilters = new List<string>();`
0	`6157`	`if (isDrmInDrmOut)`
	`6158`	`{`
0	`6159`	`if (hasSubs)`
	`6160`	`{`
0	`6161`	`var subMaxH = 1080;`
0	`6162`	`if (hasGraphicalSubs)`
	`6163`	`{`
0	`6164`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,`
0	`6165`	`subFilters.Add(subPreProcFilters);`
0	`6166`	`subFilters.Add("format=bgra");`
	`6167`	`}`
0	`6168`	`else if (hasTextSubs)`
	`6169`	`{`
0	`6170`	`var framerate = state.VideoStream?.RealFrameRate;`
0	`6171`	`var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;`
	`6172`
	`6173`	`// alphasrc=s=1280x720:r=10:start=0,format=bgra,subtitles,hwupload`
0	`6174`	`var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, subMaxH, subF`
0	`6175`	`var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);`
0	`6176`	`subFilters.Add(alphaSrcFilter);`
0	`6177`	`subFilters.Add("format=bgra");`
0	`6178`	`subFilters.Add(subTextSubtitlesFilter);`
	`6179`	`}`
	`6180`
0	`6181`	`subFilters.Add("hwupload=derive_device=rkmpp");`
	`6182`
	`6183`	`// offload 1080p+ subtitles swscale upscaling from CPU to RGA`
0	`6184`	`var (overlayW, overlayH) = GetFixedOutputSize(swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH);`
0	`6185`	`if (overlayW.HasValue && overlayH.HasValue && overlayH.Value > subMaxH)`
	`6186`	`{`
0	`6187`	`subFilters.Add($"vpp_rkrga=w={overlayW.Value}:h={overlayH.Value}:format=bgra:afbc=1");`
	`6188`	`}`
	`6189`
	`6190`	`// try enabling AFBC to save DDR bandwidth`
0	`6191`	`var hwOverlayFilter = "overlay_rkrga=eof_action=pass:repeatlast=0:format=nv12";`
0	`6192`	`if (isEncoderSupportAfbc)`
	`6193`	`{`
0	`6194`	`hwOverlayFilter += ":afbc=1";`
	`6195`	`}`
	`6196`
0	`6197`	`overlayFilters.Add(hwOverlayFilter);`
	`6198`	`}`
	`6199`	`}`
0	`6200`	`else if (memoryOutput)`
	`6201`	`{`
0	`6202`	`if (hasGraphicalSubs)`
	`6203`	`{`
0	`6204`	`var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req`
0	`6205`	`subFilters.Add(subPreProcFilters);`
0	`6206`	`overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");`
	`6207`	`}`
	`6208`	`}`
	`6209`
0	`6210`	`return (mainFilters, subFilters, overlayFilters);`
	`6211`	`}`
	`6212`
	`6213`	`/// <summary>`
	`6214`	`/// Gets the parameter of video processing filters.`
	`6215`	`/// </summary>`
	`6216`	`/// <param name="state">Encoding state.</param>`
	`6217`	`/// <param name="options">Encoding options.</param>`
	`6218`	`/// <param name="outputVideoCodec">Video codec to use.</param>`
	`6219`	`/// <returns>The video processing filters parameter.</returns>`
	`6220`	`public string GetVideoProcessingFilterParam(`
	`6221`	`EncodingJobInfo state,`
	`6222`	`EncodingOptions options,`
	`6223`	`string outputVideoCodec)`
	`6224`	`{`
0	`6225`	`var videoStream = state.VideoStream;`
0	`6226`	`if (videoStream is null)`
	`6227`	`{`
0	`6228`	`return string.Empty;`
	`6229`	`}`
	`6230`
0	`6231`	`var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);`
0	`6232`	`var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;`
0	`6233`	`var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;`
	`6234`
	`6235`	`List<string> mainFilters;`
	`6236`	`List<string> subFilters;`
	`6237`	`List<string> overlayFilters;`
	`6238`
0	`6239`	`(mainFilters, subFilters, overlayFilters) = options.HardwareAccelerationType switch`
0	`6240`	`{`
0	`6241`	`HardwareAccelerationType.vaapi => GetVaapiVidFilterChain(state, options, outputVideoCodec),`
0	`6242`	`HardwareAccelerationType.amf => GetAmdVidFilterChain(state, options, outputVideoCodec),`
0	`6243`	`HardwareAccelerationType.qsv => GetIntelVidFilterChain(state, options, outputVideoCodec),`
0	`6244`	`HardwareAccelerationType.nvenc => GetNvidiaVidFilterChain(state, options, outputVideoCodec),`
0	`6245`	`HardwareAccelerationType.videotoolbox => GetAppleVidFilterChain(state, options, outputVideoCodec),`
0	`6246`	`HardwareAccelerationType.rkmpp => GetRkmppVidFilterChain(state, options, outputVideoCodec),`
0	`6247`	`_ => GetSwVidFilterChain(state, options, outputVideoCodec),`
0	`6248`	`};`
	`6249`
0	`6250`	`mainFilters?.RemoveAll(string.IsNullOrEmpty);`
0	`6251`	`subFilters?.RemoveAll(string.IsNullOrEmpty);`
0	`6252`	`overlayFilters?.RemoveAll(string.IsNullOrEmpty);`
	`6253`
0	`6254`	`var framerate = GetFramerateParam(state);`
0	`6255`	`if (mainFilters is not null && framerate.HasValue)`
	`6256`	`{`
0	`6257`	`var doDeintH2645 = IsDeinterlaceAvailable(state);`
0	`6258`	`var fpsFilter = string.Format(CultureInfo.InvariantCulture, "fps={0}", framerate.Value);`
	`6259`
	`6260`	`// For filter chain containing the deinterlace filter,`
	`6261`	`// place the fps filter at the end to preserve temporal info.`
0	`6262`	`if (doDeintH2645)`
	`6263`	`{`
0	`6264`	`mainFilters.Add(fpsFilter);`
	`6265`	`}`
	`6266`	`else`
	`6267`	`{`
0	`6268`	`mainFilters.Insert(0, fpsFilter);`
	`6269`	`}`
	`6270`	`}`
	`6271`
0	`6272`	`var mainStr = string.Empty;`
0	`6273`	`if (mainFilters?.Count > 0)`
	`6274`	`{`
0	`6275`	`mainStr = string.Format(`
0	`6276`	`CultureInfo.InvariantCulture,`
0	`6277`	`"{0}",`
0	`6278`	`string.Join(',', mainFilters));`
	`6279`	`}`
	`6280`
0	`6281`	`if (overlayFilters?.Count == 0)`
	`6282`	`{`
	`6283`	`// -vf "scale..."`
0	`6284`	`return string.IsNullOrEmpty(mainStr) ? string.Empty : " -vf \"" + mainStr + "\"";`
	`6285`	`}`
	`6286`
0	`6287`	`if (overlayFilters?.Count > 0`
0	`6288`	`&& subFilters?.Count > 0`
0	`6289`	`&& state.SubtitleStream is not null)`
	`6290`	`{`
	`6291`	`// overlay graphical/text subtitles`
0	`6292`	`var subStr = string.Format(`
0	`6293`	`CultureInfo.InvariantCulture,`
0	`6294`	`"{0}",`
0	`6295`	`string.Join(',', subFilters));`
	`6296`
0	`6297`	`var overlayStr = string.Format(`
0	`6298`	`CultureInfo.InvariantCulture,`
0	`6299`	`"{0}",`
0	`6300`	`string.Join(',', overlayFilters));`
	`6301`
0	`6302`	`var mapPrefix = Convert.ToInt32(state.SubtitleStream.IsExternal);`
0	`6303`	`var subtitleStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.SubtitleStream);`
0	`6304`	`var videoStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.VideoStream);`
	`6305`
0	`6306`	`if (hasSubs)`
	`6307`	`{`
	`6308`	`// -filter_complex "[0:s]scale=s[sub]..."`
0	`6309`	`var filterStr = string.IsNullOrEmpty(mainStr)`
0	`6310`	`? " -filter_complex \"[{0}:{1}]{4}[sub];[0:{2}][sub]{5}\""`
0	`6311`	`: " -filter_complex \"[{0}:{1}]{4}[sub];[0:{2}]{3}[main];[main][sub]{5}\"";`
	`6312`
0	`6313`	`if (hasTextSubs)`
	`6314`	`{`
0	`6315`	`filterStr = string.IsNullOrEmpty(mainStr)`
0	`6316`	`? " -filter_complex \"{4}[sub];[0:{2}][sub]{5}\""`
0	`6317`	`: " -filter_complex \"{4}[sub];[0:{2}]{3}[main];[main][sub]{5}\"";`
	`6318`	`}`
	`6319`
0	`6320`	`return string.Format(`
0	`6321`	`CultureInfo.InvariantCulture,`
0	`6322`	`filterStr,`
0	`6323`	`mapPrefix,`
0	`6324`	`subtitleStreamIndex,`
0	`6325`	`videoStreamIndex,`
0	`6326`	`mainStr,`
0	`6327`	`subStr,`
0	`6328`	`overlayStr);`
	`6329`	`}`
	`6330`	`}`
	`6331`
0	`6332`	`return string.Empty;`
	`6333`	`}`
	`6334`
	`6335`	`public string GetOverwriteColorPropertiesParam(EncodingJobInfo state, bool isTonemapAvailable)`
	`6336`	`{`
0	`6337`	`if (isTonemapAvailable)`
	`6338`	`{`
0	`6339`	`return GetInputHdrParam(state.VideoStream?.ColorTransfer);`
	`6340`	`}`
	`6341`
0	`6342`	`return GetOutputSdrParam(null);`
	`6343`	`}`
	`6344`
	`6345`	`public string GetInputHdrParam(string colorTransfer)`
	`6346`	`{`
0	`6347`	`if (string.Equals(colorTransfer, "arib-std-b67", StringComparison.OrdinalIgnoreCase))`
	`6348`	`{`
	`6349`	`// HLG`
0	`6350`	`return "setparams=color_primaries=bt2020:color_trc=arib-std-b67:colorspace=bt2020nc";`
	`6351`	`}`
	`6352`
	`6353`	`// HDR10`
0	`6354`	`return "setparams=color_primaries=bt2020:color_trc=smpte2084:colorspace=bt2020nc";`
	`6355`	`}`
	`6356`
	`6357`	`public string GetOutputSdrParam(string tonemappingRange)`
	`6358`	`{`
	`6359`	`// SDR`
0	`6360`	`if (string.Equals(tonemappingRange, "tv", StringComparison.OrdinalIgnoreCase))`
	`6361`	`{`
0	`6362`	`return "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709:range=tv";`
	`6363`	`}`
	`6364`
0	`6365`	`if (string.Equals(tonemappingRange, "pc", StringComparison.OrdinalIgnoreCase))`
	`6366`	`{`
0	`6367`	`return "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709:range=pc";`
	`6368`	`}`
	`6369`
0	`6370`	`return "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709";`
	`6371`	`}`
	`6372`
	`6373`	`public static int GetVideoColorBitDepth(EncodingJobInfo state)`
	`6374`	`{`
0	`6375`	`var videoStream = state.VideoStream;`
0	`6376`	`if (videoStream is not null)`
	`6377`	`{`
0	`6378`	`if (videoStream.BitDepth.HasValue)`
	`6379`	`{`
0	`6380`	`return videoStream.BitDepth.Value;`
	`6381`	`}`
	`6382`
0	`6383`	`if (string.Equals(videoStream.PixelFormat, "yuv420p", StringComparison.OrdinalIgnoreCase)`
0	`6384`	`\|\| string.Equals(videoStream.PixelFormat, "yuvj420p", StringComparison.OrdinalIgnoreCase)`
0	`6385`	`\|\| string.Equals(videoStream.PixelFormat, "yuv422p", StringComparison.OrdinalIgnoreCase)`
0	`6386`	`\|\| string.Equals(videoStream.PixelFormat, "yuv444p", StringComparison.OrdinalIgnoreCase))`
	`6387`	`{`
0	`6388`	`return 8;`
	`6389`	`}`
	`6390`
0	`6391`	`if (string.Equals(videoStream.PixelFormat, "yuv420p10le", StringComparison.OrdinalIgnoreCase)`
0	`6392`	`\|\| string.Equals(videoStream.PixelFormat, "yuv422p10le", StringComparison.OrdinalIgnoreCase)`
0	`6393`	`\|\| string.Equals(videoStream.PixelFormat, "yuv444p10le", StringComparison.OrdinalIgnoreCase))`
	`6394`	`{`
0	`6395`	`return 10;`
	`6396`	`}`
	`6397`
0	`6398`	`if (string.Equals(videoStream.PixelFormat, "yuv420p12le", StringComparison.OrdinalIgnoreCase)`
0	`6399`	`\|\| string.Equals(videoStream.PixelFormat, "yuv422p12le", StringComparison.OrdinalIgnoreCase)`
0	`6400`	`\|\| string.Equals(videoStream.PixelFormat, "yuv444p12le", StringComparison.OrdinalIgnoreCase))`
	`6401`	`{`
0	`6402`	`return 12;`
	`6403`	`}`
	`6404`
0	`6405`	`return 8;`
	`6406`	`}`
	`6407`
0	`6408`	`return 0;`
	`6409`	`}`
	`6410`
	`6411`	`/// <summary>`
	`6412`	`/// Gets the ffmpeg option string for the hardware accelerated video decoder.`
	`6413`	`/// </summary>`
	`6414`	`/// <param name="state">The encoding job info.</param>`
	`6415`	`/// <param name="options">The encoding options.</param>`
	`6416`	`/// <returns>The option string or null if none available.</returns>`
	`6417`	`protected string GetHardwareVideoDecoder(EncodingJobInfo state, EncodingOptions options)`
	`6418`	`{`
4	`6419`	`var videoStream = state.VideoStream;`
4	`6420`	`var mediaSource = state.MediaSource;`
4	`6421`	`if (videoStream is null \|\| mediaSource is null)`
	`6422`	`{`
0	`6423`	`return null;`
	`6424`	`}`
	`6425`
	`6426`	`// HWA decoders can handle both video files and video folders.`
4	`6427`	`var videoType = state.VideoType;`
4	`6428`	`if (videoType != VideoType.VideoFile`
4	`6429`	`&& videoType != VideoType.Iso`
4	`6430`	`&& videoType != VideoType.Dvd`
4	`6431`	`&& videoType != VideoType.BluRay)`
	`6432`	`{`
0	`6433`	`return null;`
	`6434`	`}`
	`6435`
4	`6436`	`if (IsCopyCodec(state.OutputVideoCodec))`
	`6437`	`{`
0	`6438`	`return null;`
	`6439`	`}`
	`6440`
4	`6441`	`var hardwareAccelerationType = options.HardwareAccelerationType;`
	`6442`
4	`6443`	`if (!string.IsNullOrEmpty(videoStream.Codec) && hardwareAccelerationType != HardwareAccelerationType.none)`
	`6444`	`{`
0	`6445`	`var bitDepth = GetVideoColorBitDepth(state);`
	`6446`
	`6447`	`// Only HEVC, VP9 and AV1 formats have 10-bit hardware decoder support for most platforms`
0	`6448`	`if (bitDepth == 10`
0	`6449`	`&& !(string.Equals(videoStream.Codec, "hevc", StringComparison.OrdinalIgnoreCase)`
0	`6450`	`\|\| string.Equals(videoStream.Codec, "h265", StringComparison.OrdinalIgnoreCase)`
0	`6451`	`\|\| string.Equals(videoStream.Codec, "vp9", StringComparison.OrdinalIgnoreCase)`
0	`6452`	`\|\| string.Equals(videoStream.Codec, "av1", StringComparison.OrdinalIgnoreCase)))`
	`6453`	`{`
	`6454`	`// RKMPP has H.264 Hi10P decoder`
0	`6455`	`bool hasHardwareHi10P = hardwareAccelerationType == HardwareAccelerationType.rkmpp;`
	`6456`
	`6457`	`// VideoToolbox on Apple Silicon has H.264 Hi10P mode enabled after macOS 14.6`
0	`6458`	`if (hardwareAccelerationType == HardwareAccelerationType.videotoolbox)`
	`6459`	`{`
0	`6460`	`var ver = Environment.OSVersion.Version;`
0	`6461`	`var arch = RuntimeInformation.OSArchitecture;`
0	`6462`	`if (arch.Equals(Architecture.Arm64) && ver >= new Version(14, 6))`
	`6463`	`{`
0	`6464`	`hasHardwareHi10P = true;`
	`6465`	`}`
	`6466`	`}`
	`6467`
0	`6468`	`if (!hasHardwareHi10P`
0	`6469`	`&& string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase))`
	`6470`	`{`
0	`6471`	`return null;`
	`6472`	`}`
	`6473`	`}`
	`6474`
	`6475`	`// Block unsupported H.264 Hi422P and Hi444PP profiles, which can be encoded with 4:2:0 pixel format`
0	`6476`	`if (string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase)`
0	`6477`	`&& ((videoStream.Profile?.Contains("4:2:2", StringComparison.OrdinalIgnoreCase) ?? false)`
0	`6478`	`\|\| (videoStream.Profile?.Contains("4:4:4", StringComparison.OrdinalIgnoreCase) ?? false)))`
	`6479`	`{`
	`6480`	`// VideoToolbox on Apple Silicon has H.264 Hi444PP and theoretically also has Hi422P`
0	`6481`	`if (!(hardwareAccelerationType == HardwareAccelerationType.videotoolbox`
0	`6482`	`&& RuntimeInformation.OSArchitecture.Equals(Architecture.Arm64)))`
	`6483`	`{`
0	`6484`	`return null;`
	`6485`	`}`
	`6486`	`}`
	`6487`
0	`6488`	`var decoder = hardwareAccelerationType switch`
0	`6489`	`{`
0	`6490`	`HardwareAccelerationType.vaapi => GetVaapiVidDecoder(state, options, videoStream, bitDepth),`
0	`6491`	`HardwareAccelerationType.amf => GetAmfVidDecoder(state, options, videoStream, bitDepth),`
0	`6492`	`HardwareAccelerationType.qsv => GetQsvHwVidDecoder(state, options, videoStream, bitDepth),`
0	`6493`	`HardwareAccelerationType.nvenc => GetNvdecVidDecoder(state, options, videoStream, bitDepth),`
0	`6494`	`HardwareAccelerationType.videotoolbox => GetVideotoolboxVidDecoder(state, options, videoStream, bitD`
0	`6495`	`HardwareAccelerationType.rkmpp => GetRkmppVidDecoder(state, options, videoStream, bitDepth),`
0	`6496`	`_ => string.Empty`
0	`6497`	`};`
	`6498`
0	`6499`	`if (!string.IsNullOrEmpty(decoder))`
	`6500`	`{`
0	`6501`	`return decoder;`
	`6502`	`}`
	`6503`	`}`
	`6504`
	`6505`	`// leave blank so ffmpeg will decide`
4	`6506`	`return null;`
	`6507`	`}`
	`6508`
	`6509`	`/// <summary>`
	`6510`	`/// Gets a hw decoder name.`
	`6511`	`/// </summary>`
	`6512`	`/// <param name="options">Encoding options.</param>`
	`6513`	`/// <param name="decoderPrefix">Decoder prefix.</param>`
	`6514`	`/// <param name="decoderSuffix">Decoder suffix.</param>`
	`6515`	`/// <param name="videoCodec">Video codec to use.</param>`
	`6516`	`/// <param name="bitDepth">Video color bit depth.</param>`
	`6517`	`/// <returns>Hardware decoder name.</returns>`
	`6518`	`public string GetHwDecoderName(EncodingOptions options, string decoderPrefix, string decoderSuffix, string video`
	`6519`	`{`
0	`6520`	`if (string.IsNullOrEmpty(decoderPrefix) \|\| string.IsNullOrEmpty(decoderSuffix))`
	`6521`	`{`
0	`6522`	`return null;`
	`6523`	`}`
	`6524`
0	`6525`	`var decoderName = decoderPrefix + '_' + decoderSuffix;`
	`6526`
0	`6527`	`var isCodecAvailable = _mediaEncoder.SupportsDecoder(decoderName) && options.HardwareDecodingCodecs.Contains`
	`6528`
	`6529`	`// VideoToolbox decoders have built-in SW fallback`
0	`6530`	`if (bitDepth == 10`
0	`6531`	`&& isCodecAvailable`
0	`6532`	`&& (options.HardwareAccelerationType != HardwareAccelerationType.videotoolbox))`
	`6533`	`{`
0	`6534`	`if (string.Equals(videoCodec, "hevc", StringComparison.OrdinalIgnoreCase)`
0	`6535`	`&& options.HardwareDecodingCodecs.Contains("hevc", StringComparison.OrdinalIgnoreCase)`
0	`6536`	`&& !options.EnableDecodingColorDepth10Hevc)`
	`6537`	`{`
0	`6538`	`return null;`
	`6539`	`}`
	`6540`
0	`6541`	`if (string.Equals(videoCodec, "vp9", StringComparison.OrdinalIgnoreCase)`
0	`6542`	`&& options.HardwareDecodingCodecs.Contains("vp9", StringComparison.OrdinalIgnoreCase)`
0	`6543`	`&& !options.EnableDecodingColorDepth10Vp9)`
	`6544`	`{`
0	`6545`	`return null;`
	`6546`	`}`
	`6547`	`}`
	`6548`
0	`6549`	`if (string.Equals(decoderSuffix, "cuvid", StringComparison.OrdinalIgnoreCase) && options.EnableEnhancedNvdec`
	`6550`	`{`
0	`6551`	`return null;`
	`6552`	`}`
	`6553`
0	`6554`	`if (string.Equals(decoderSuffix, "qsv", StringComparison.OrdinalIgnoreCase) && options.PreferSystemNativeHwD`
	`6555`	`{`
0	`6556`	`return null;`
	`6557`	`}`
	`6558`
0	`6559`	`if (string.Equals(decoderSuffix, "rkmpp", StringComparison.OrdinalIgnoreCase))`
	`6560`	`{`
0	`6561`	`return null;`
	`6562`	`}`
	`6563`
0	`6564`	`return isCodecAvailable ? (" -c:v " + decoderName) : null;`
	`6565`	`}`
	`6566`
	`6567`	`/// <summary>`
	`6568`	`/// Gets a hwaccel type to use as a hardware decoder depending on the system.`
	`6569`	`/// </summary>`
	`6570`	`/// <param name="state">Encoding state.</param>`
	`6571`	`/// <param name="options">Encoding options.</param>`
	`6572`	`/// <param name="videoCodec">Video codec to use.</param>`
	`6573`	`/// <param name="bitDepth">Video color bit depth.</param>`
	`6574`	`/// <param name="outputHwSurface">Specifies if output hw surface.</param>`
	`6575`	`/// <returns>Hardware accelerator type.</returns>`
	`6576`	`public string GetHwaccelType(EncodingJobInfo state, EncodingOptions options, string videoCodec, int bitDepth, bo`
	`6577`	`{`
0	`6578`	`var isWindows = OperatingSystem.IsWindows();`
0	`6579`	`var isLinux = OperatingSystem.IsLinux();`
0	`6580`	`var isMacOS = OperatingSystem.IsMacOS();`
0	`6581`	`var isD3d11Supported = isWindows && _mediaEncoder.SupportsHwaccel("d3d11va");`
0	`6582`	`var isVaapiSupported = isLinux && IsVaapiSupported(state);`
0	`6583`	`var isCudaSupported = (isLinux \|\| isWindows) && IsCudaFullSupported();`
0	`6584`	`var isQsvSupported = (isLinux \|\| isWindows) && _mediaEncoder.SupportsHwaccel("qsv");`
0	`6585`	`var isVideotoolboxSupported = isMacOS && _mediaEncoder.SupportsHwaccel("videotoolbox");`
0	`6586`	`var isRkmppSupported = isLinux && IsRkmppFullSupported();`
0	`6587`	`var isCodecAvailable = options.HardwareDecodingCodecs.Contains(videoCodec, StringComparison.OrdinalIgnoreCas`
0	`6588`	`var hardwareAccelerationType = options.HardwareAccelerationType;`
	`6589`
0	`6590`	`var ffmpegVersion = _mediaEncoder.EncoderVersion;`
	`6591`
	`6592`	`// Set the av1 codec explicitly to trigger hw accelerator, otherwise libdav1d will be used.`
0	`6593`	`var isAv1 = ffmpegVersion < _minFFmpegImplicitHwaccel`
0	`6594`	`&& string.Equals(videoCodec, "av1", StringComparison.OrdinalIgnoreCase);`
	`6595`
	`6596`	`// Allow profile mismatch if decoding H.264 baseline with d3d11va and vaapi hwaccels.`
0	`6597`	`var profileMismatch = string.Equals(videoCodec, "h264", StringComparison.OrdinalIgnoreCase)`
0	`6598`	`&& string.Equals(state.VideoStream?.Profile, "baseline", StringComparison.OrdinalIgnoreCase);`
	`6599`
	`6600`	`// Disable the extra internal copy in nvdec. We already handle it in filter chain.`
0	`6601`	`var nvdecNoInternalCopy = ffmpegVersion >= _minFFmpegHwaUnsafeOutput;`
	`6602`
	`6603`	`// Strip the display rotation side data from the transposed fmp4 output stream.`
0	`6604`	`var stripRotationData = (state.VideoStream?.Rotation ?? 0) != 0`
0	`6605`	`&& ffmpegVersion >= _minFFmpegDisplayRotationOption;`
0	`6606`	`var stripRotationDataArgs = stripRotationData ? " -display_rotation 0" : string.Empty;`
	`6607`
	`6608`	`// VideoToolbox decoders have built-in SW fallback`
0	`6609`	`if (isCodecAvailable`
0	`6610`	`&& (options.HardwareAccelerationType != HardwareAccelerationType.videotoolbox))`
	`6611`	`{`
0	`6612`	`if (string.Equals(videoCodec, "hevc", StringComparison.OrdinalIgnoreCase)`
0	`6613`	`&& options.HardwareDecodingCodecs.Contains("hevc", StringComparison.OrdinalIgnoreCase))`
	`6614`	`{`
0	`6615`	`if (IsVideoStreamHevcRext(state))`
	`6616`	`{`
0	`6617`	`if (bitDepth <= 10 && !options.EnableDecodingColorDepth10HevcRext)`
	`6618`	`{`
0	`6619`	`return null;`
	`6620`	`}`
	`6621`
0	`6622`	`if (bitDepth == 12 && !options.EnableDecodingColorDepth12HevcRext)`
	`6623`	`{`
0	`6624`	`return null;`
	`6625`	`}`
	`6626`
0	`6627`	`if (hardwareAccelerationType == HardwareAccelerationType.vaapi`
0	`6628`	`&& !_mediaEncoder.IsVaapiDeviceInteliHD)`
	`6629`	`{`
0	`6630`	`return null;`
	`6631`	`}`
	`6632`	`}`
0	`6633`	`else if (bitDepth == 10 && !options.EnableDecodingColorDepth10Hevc)`
	`6634`	`{`
0	`6635`	`return null;`
	`6636`	`}`
	`6637`	`}`
	`6638`
0	`6639`	`if (string.Equals(videoCodec, "vp9", StringComparison.OrdinalIgnoreCase)`
0	`6640`	`&& options.HardwareDecodingCodecs.Contains("vp9", StringComparison.OrdinalIgnoreCase)`
0	`6641`	`&& bitDepth == 10`
0	`6642`	`&& !options.EnableDecodingColorDepth10Vp9)`
	`6643`	`{`
0	`6644`	`return null;`
	`6645`	`}`
	`6646`	`}`
	`6647`
	`6648`	`// Intel qsv/d3d11va/vaapi`
0	`6649`	`if (hardwareAccelerationType == HardwareAccelerationType.qsv)`
	`6650`	`{`
0	`6651`	`if (options.PreferSystemNativeHwDecoder)`
	`6652`	`{`
0	`6653`	`if (isVaapiSupported && isCodecAvailable)`
	`6654`	`{`
0	`6655`	`return " -hwaccel vaapi" + (outputHwSurface ? " -hwaccel_output_format vaapi -noautorotate" + st`
0	`6656`	`+ (profileMismatch ? " -hwaccel_flags +allow_profile_mismatch" : string.Empty) + (isAv1 ? "`
	`6657`	`}`
	`6658`
0	`6659`	`if (isD3d11Supported && isCodecAvailable)`
	`6660`	`{`
0	`6661`	`return " -hwaccel d3d11va" + (outputHwSurface ? " -hwaccel_output_format d3d11 -noautorotate" +`
0	`6662`	`+ (profileMismatch ? " -hwaccel_flags +allow_profile_mismatch" : string.Empty) + " -threads`
	`6663`	`}`
	`6664`	`}`
	`6665`	`else`
	`6666`	`{`
0	`6667`	`if (isQsvSupported && isCodecAvailable)`
	`6668`	`{`
0	`6669`	`return " -hwaccel qsv" + (outputHwSurface ? " -hwaccel_output_format qsv -noautorotate" + stripR`
	`6670`	`}`
	`6671`	`}`
	`6672`	`}`
	`6673`
	`6674`	`// Nvidia cuda`
0	`6675`	`if (hardwareAccelerationType == HardwareAccelerationType.nvenc)`
	`6676`	`{`
0	`6677`	`if (isCudaSupported && isCodecAvailable)`
	`6678`	`{`
0	`6679`	`if (options.EnableEnhancedNvdecDecoder)`
	`6680`	`{`
	`6681`	`// set -threads 1 to nvdec decoder explicitly since it doesn't implement threading support.`
0	`6682`	`return " -hwaccel cuda" + (outputHwSurface ? " -hwaccel_output_format cuda -noautorotate" + stri`
0	`6683`	`+ (nvdecNoInternalCopy ? " -hwaccel_flags +unsafe_output" : string.Empty) + " -threads 1" +`
	`6684`	`}`
	`6685`
	`6686`	`// cuvid decoder doesn't have threading issue.`
0	`6687`	`return " -hwaccel cuda" + (outputHwSurface ? " -hwaccel_output_format cuda -noautorotate" + stripRot`
	`6688`	`}`
	`6689`	`}`
	`6690`
	`6691`	`// Amd d3d11va`
0	`6692`	`if (hardwareAccelerationType == HardwareAccelerationType.amf)`
	`6693`	`{`
0	`6694`	`if (isD3d11Supported && isCodecAvailable)`
	`6695`	`{`
0	`6696`	`return " -hwaccel d3d11va" + (outputHwSurface ? " -hwaccel_output_format d3d11 -noautorotate" + stri`
0	`6697`	`+ (profileMismatch ? " -hwaccel_flags +allow_profile_mismatch" : string.Empty) + " -threads 2" +`
	`6698`	`}`
	`6699`	`}`
	`6700`
	`6701`	`// Vaapi`
0	`6702`	`if (hardwareAccelerationType == HardwareAccelerationType.vaapi`
0	`6703`	`&& isVaapiSupported`
0	`6704`	`&& isCodecAvailable)`
	`6705`	`{`
0	`6706`	`return " -hwaccel vaapi" + (outputHwSurface ? " -hwaccel_output_format vaapi -noautorotate" + stripRotat`
0	`6707`	`+ (profileMismatch ? " -hwaccel_flags +allow_profile_mismatch" : string.Empty) + (isAv1 ? " -c:v av1`
	`6708`	`}`
	`6709`
	`6710`	`// Apple videotoolbox`
0	`6711`	`if (hardwareAccelerationType == HardwareAccelerationType.videotoolbox`
0	`6712`	`&& isVideotoolboxSupported`
0	`6713`	`&& isCodecAvailable)`
	`6714`	`{`
0	`6715`	`return " -hwaccel videotoolbox" + (outputHwSurface ? " -hwaccel_output_format videotoolbox_vld" : string`
	`6716`	`}`
	`6717`
	`6718`	`// Rockchip rkmpp`
0	`6719`	`if (hardwareAccelerationType == HardwareAccelerationType.rkmpp`
0	`6720`	`&& isRkmppSupported`
0	`6721`	`&& isCodecAvailable)`
	`6722`	`{`
0	`6723`	`return " -hwaccel rkmpp" + (outputHwSurface ? " -hwaccel_output_format drm_prime -noautorotate" + stripR`
	`6724`	`}`
	`6725`
0	`6726`	`return null;`
	`6727`	`}`
	`6728`
	`6729`	`public string GetQsvHwVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bi`
	`6730`	`{`
0	`6731`	`var isWindows = OperatingSystem.IsWindows();`
0	`6732`	`var isLinux = OperatingSystem.IsLinux();`
	`6733`
0	`6734`	`if ((!isWindows && !isLinux)`
0	`6735`	`\|\| options.HardwareAccelerationType != HardwareAccelerationType.qsv)`
	`6736`	`{`
0	`6737`	`return null;`
	`6738`	`}`
	`6739`
0	`6740`	`var isQsvOclSupported = _mediaEncoder.SupportsHwaccel("qsv") && IsOpenclFullSupported();`
0	`6741`	`var isIntelDx11OclSupported = isWindows`
0	`6742`	`&& _mediaEncoder.SupportsHwaccel("d3d11va")`
0	`6743`	`&& isQsvOclSupported;`
0	`6744`	`var isIntelVaapiOclSupported = isLinux`
0	`6745`	`&& IsVaapiSupported(state)`
0	`6746`	`&& isQsvOclSupported;`
0	`6747`	`var hwSurface = (isIntelDx11OclSupported \|\| isIntelVaapiOclSupported)`
0	`6748`	`&& _mediaEncoder.SupportsFilter("alphasrc");`
	`6749`
0	`6750`	`var is8bitSwFormatsQsv = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCas`
0	`6751`	`\|\| string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgnor`
0	`6752`	`var is8_10bitSwFormatsQsv = is8bitSwFormatsQsv \|\| string.Equals("yuv420p10le", videoStream.PixelFormat, Stri`
0	`6753`	`var is8_10_12bitSwFormatsQsv = is8_10bitSwFormatsQsv`
0	`6754`	`\|\| string.Equals("yuv422p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6755`	`\|\| string.Equals("yuv444p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6756`	`\|\| string.Equals("yuv422p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6757`	`\|\| string.Equals("yuv444p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6758`	`\|\| string.Equals("yuv420p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6759`	`\|\| string.Equals("yuv422p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6760`	`\|\| string.Equals("yuv444p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase);`
	`6761`	`// TODO: add more 8/10bit and 4:4:4 formats for Qsv after finishing the ffcheck tool`
	`6762`
0	`6763`	`if (is8bitSwFormatsQsv)`
	`6764`	`{`
0	`6765`	`if (string.Equals(videoStream.Codec, "avc", StringComparison.OrdinalIgnoreCase)`
0	`6766`	`\|\| string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase))`
	`6767`	`{`
0	`6768`	`return GetHwaccelType(state, options, "h264", bitDepth, hwSurface) + GetHwDecoderName(options, "h264`
	`6769`	`}`
	`6770`
0	`6771`	`if (string.Equals(videoStream.Codec, "vc1", StringComparison.OrdinalIgnoreCase))`
	`6772`	`{`
0	`6773`	`return GetHwaccelType(state, options, "vc1", bitDepth, hwSurface) + GetHwDecoderName(options, "vc1",`
	`6774`	`}`
	`6775`
0	`6776`	`if (string.Equals(videoStream.Codec, "vp8", StringComparison.OrdinalIgnoreCase))`
	`6777`	`{`
0	`6778`	`return GetHwaccelType(state, options, "vp8", bitDepth, hwSurface) + GetHwDecoderName(options, "vp8",`
	`6779`	`}`
	`6780`
0	`6781`	`if (string.Equals(videoStream.Codec, "mpeg2video", StringComparison.OrdinalIgnoreCase))`
	`6782`	`{`
0	`6783`	`return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface) + GetHwDecoderName(options,`
	`6784`	`}`
	`6785`	`}`
	`6786`
0	`6787`	`if (is8_10bitSwFormatsQsv)`
	`6788`	`{`
0	`6789`	`if (string.Equals(videoStream.Codec, "vp9", StringComparison.OrdinalIgnoreCase))`
	`6790`	`{`
0	`6791`	`return GetHwaccelType(state, options, "vp9", bitDepth, hwSurface) + GetHwDecoderName(options, "vp9",`
	`6792`	`}`
	`6793`
0	`6794`	`if (string.Equals(videoStream.Codec, "av1", StringComparison.OrdinalIgnoreCase))`
	`6795`	`{`
0	`6796`	`return GetHwaccelType(state, options, "av1", bitDepth, hwSurface) + GetHwDecoderName(options, "av1",`
	`6797`	`}`
	`6798`	`}`
	`6799`
0	`6800`	`if (is8_10_12bitSwFormatsQsv)`
	`6801`	`{`
0	`6802`	`if (string.Equals(videoStream.Codec, "hevc", StringComparison.OrdinalIgnoreCase)`
0	`6803`	`\|\| string.Equals(videoStream.Codec, "h265", StringComparison.OrdinalIgnoreCase))`
	`6804`	`{`
0	`6805`	`return GetHwaccelType(state, options, "hevc", bitDepth, hwSurface) + GetHwDecoderName(options, "hevc`
	`6806`	`}`
	`6807`	`}`
	`6808`
0	`6809`	`return null;`
	`6810`	`}`
	`6811`
	`6812`	`public string GetNvdecVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bi`
	`6813`	`{`
0	`6814`	`if ((!OperatingSystem.IsWindows() && !OperatingSystem.IsLinux())`
0	`6815`	`\|\| options.HardwareAccelerationType != HardwareAccelerationType.nvenc)`
	`6816`	`{`
0	`6817`	`return null;`
	`6818`	`}`
	`6819`
0	`6820`	`var hwSurface = IsCudaFullSupported() && _mediaEncoder.SupportsFilter("alphasrc");`
0	`6821`	`var is8bitSwFormatsNvdec = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreC`
0	`6822`	`\|\| string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgn`
0	`6823`	`var is8_10bitSwFormatsNvdec = is8bitSwFormatsNvdec \|\| string.Equals("yuv420p10le", videoStream.PixelFormat,`
0	`6824`	`var is8_10_12bitSwFormatsNvdec = is8_10bitSwFormatsNvdec`
0	`6825`	`\|\| string.Equals("yuv444p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6826`	`\|\| string.Equals("yuv444p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6827`	`\|\| string.Equals("yuv420p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6828`	`\|\| string.Equals("yuv444p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase);`
	`6829`	`// TODO: add more 8/10/12bit and 4:4:4 formats for Nvdec after finishing the ffcheck tool`
	`6830`
0	`6831`	`if (is8bitSwFormatsNvdec)`
	`6832`	`{`
0	`6833`	`if (string.Equals("avc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`6834`	`\|\| string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6835`	`{`
0	`6836`	`return GetHwaccelType(state, options, "h264", bitDepth, hwSurface) + GetHwDecoderName(options, "h264`
	`6837`	`}`
	`6838`
0	`6839`	`if (string.Equals("mpeg2video", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6840`	`{`
0	`6841`	`return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface) + GetHwDecoderName(options,`
	`6842`	`}`
	`6843`
0	`6844`	`if (string.Equals("vc1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6845`	`{`
0	`6846`	`return GetHwaccelType(state, options, "vc1", bitDepth, hwSurface) + GetHwDecoderName(options, "vc1",`
	`6847`	`}`
	`6848`
0	`6849`	`if (string.Equals("mpeg4", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6850`	`{`
0	`6851`	`return GetHwaccelType(state, options, "mpeg4", bitDepth, hwSurface) + GetHwDecoderName(options, "mpe`
	`6852`	`}`
	`6853`
0	`6854`	`if (string.Equals("vp8", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6855`	`{`
0	`6856`	`return GetHwaccelType(state, options, "vp8", bitDepth, hwSurface) + GetHwDecoderName(options, "vp8",`
	`6857`	`}`
	`6858`	`}`
	`6859`
0	`6860`	`if (is8_10bitSwFormatsNvdec)`
	`6861`	`{`
0	`6862`	`if (string.Equals("vp9", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6863`	`{`
0	`6864`	`return GetHwaccelType(state, options, "vp9", bitDepth, hwSurface) + GetHwDecoderName(options, "vp9",`
	`6865`	`}`
	`6866`
0	`6867`	`if (string.Equals("av1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6868`	`{`
0	`6869`	`return GetHwaccelType(state, options, "av1", bitDepth, hwSurface) + GetHwDecoderName(options, "av1",`
	`6870`	`}`
	`6871`	`}`
	`6872`
0	`6873`	`if (is8_10_12bitSwFormatsNvdec)`
	`6874`	`{`
0	`6875`	`if (string.Equals("hevc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`6876`	`\|\| string.Equals("h265", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6877`	`{`
0	`6878`	`return GetHwaccelType(state, options, "hevc", bitDepth, hwSurface) + GetHwDecoderName(options, "hevc`
	`6879`	`}`
	`6880`	`}`
	`6881`
0	`6882`	`return null;`
	`6883`	`}`
	`6884`
	`6885`	`public string GetAmfVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bitD`
	`6886`	`{`
0	`6887`	`if (!OperatingSystem.IsWindows()`
0	`6888`	`\|\| options.HardwareAccelerationType != HardwareAccelerationType.amf)`
	`6889`	`{`
0	`6890`	`return null;`
	`6891`	`}`
	`6892`
0	`6893`	`var hwSurface = _mediaEncoder.SupportsHwaccel("d3d11va")`
0	`6894`	`&& IsOpenclFullSupported()`
0	`6895`	`&& _mediaEncoder.SupportsFilter("alphasrc");`
0	`6896`	`var is8bitSwFormatsAmf = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCas`
0	`6897`	`\|\| string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgnor`
0	`6898`	`var is8_10bitSwFormatsAmf = is8bitSwFormatsAmf \|\| string.Equals("yuv420p10le", videoStream.PixelFormat, Stri`
	`6899`
0	`6900`	`if (is8bitSwFormatsAmf)`
	`6901`	`{`
0	`6902`	`if (string.Equals("avc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`6903`	`\|\| string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6904`	`{`
0	`6905`	`return GetHwaccelType(state, options, "h264", bitDepth, hwSurface);`
	`6906`	`}`
	`6907`
0	`6908`	`if (string.Equals("mpeg2video", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6909`	`{`
0	`6910`	`return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface);`
	`6911`	`}`
	`6912`
0	`6913`	`if (string.Equals("vc1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6914`	`{`
0	`6915`	`return GetHwaccelType(state, options, "vc1", bitDepth, hwSurface);`
	`6916`	`}`
	`6917`	`}`
	`6918`
0	`6919`	`if (is8_10bitSwFormatsAmf)`
	`6920`	`{`
0	`6921`	`if (string.Equals("hevc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`6922`	`\|\| string.Equals("h265", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6923`	`{`
0	`6924`	`return GetHwaccelType(state, options, "hevc", bitDepth, hwSurface);`
	`6925`	`}`
	`6926`
0	`6927`	`if (string.Equals("vp9", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6928`	`{`
0	`6929`	`return GetHwaccelType(state, options, "vp9", bitDepth, hwSurface);`
	`6930`	`}`
	`6931`
0	`6932`	`if (string.Equals("av1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6933`	`{`
0	`6934`	`return GetHwaccelType(state, options, "av1", bitDepth, hwSurface);`
	`6935`	`}`
	`6936`	`}`
	`6937`
0	`6938`	`return null;`
	`6939`	`}`
	`6940`
	`6941`	`public string GetVaapiVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bi`
	`6942`	`{`
0	`6943`	`if (!OperatingSystem.IsLinux()`
0	`6944`	`\|\| options.HardwareAccelerationType != HardwareAccelerationType.vaapi)`
	`6945`	`{`
0	`6946`	`return null;`
	`6947`	`}`
	`6948`
0	`6949`	`var hwSurface = IsVaapiSupported(state)`
0	`6950`	`&& IsVaapiFullSupported()`
0	`6951`	`&& IsOpenclFullSupported()`
0	`6952`	`&& _mediaEncoder.SupportsFilter("alphasrc");`
0	`6953`	`var is8bitSwFormatsVaapi = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreC`
0	`6954`	`\|\| string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgn`
0	`6955`	`var is8_10bitSwFormatsVaapi = is8bitSwFormatsVaapi \|\| string.Equals("yuv420p10le", videoStream.PixelFormat,`
0	`6956`	`var is8_10_12bitSwFormatsVaapi = is8_10bitSwFormatsVaapi`
0	`6957`	`\|\| string.Equals("yuv422p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6958`	`\|\| string.Equals("yuv444p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6959`	`\|\| string.Equals("yuv422p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6960`	`\|\| string.Equals("yuv444p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6961`	`\|\| string.Equals("yuv420p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6962`	`\|\| string.Equals("yuv422p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`6963`	`\|\| string.Equals("yuv444p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase);`
	`6964`
0	`6965`	`if (is8bitSwFormatsVaapi)`
	`6966`	`{`
0	`6967`	`if (string.Equals("avc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`6968`	`\|\| string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6969`	`{`
0	`6970`	`return GetHwaccelType(state, options, "h264", bitDepth, hwSurface);`
	`6971`	`}`
	`6972`
0	`6973`	`if (string.Equals("mpeg2video", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6974`	`{`
0	`6975`	`return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface);`
	`6976`	`}`
	`6977`
0	`6978`	`if (string.Equals("vc1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6979`	`{`
0	`6980`	`return GetHwaccelType(state, options, "vc1", bitDepth, hwSurface);`
	`6981`	`}`
	`6982`
0	`6983`	`if (string.Equals("vp8", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6984`	`{`
0	`6985`	`return GetHwaccelType(state, options, "vp8", bitDepth, hwSurface);`
	`6986`	`}`
	`6987`	`}`
	`6988`
0	`6989`	`if (is8_10bitSwFormatsVaapi)`
	`6990`	`{`
0	`6991`	`if (string.Equals("vp9", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6992`	`{`
0	`6993`	`return GetHwaccelType(state, options, "vp9", bitDepth, hwSurface);`
	`6994`	`}`
	`6995`
0	`6996`	`if (string.Equals("av1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`6997`	`{`
0	`6998`	`return GetHwaccelType(state, options, "av1", bitDepth, hwSurface);`
	`6999`	`}`
	`7000`	`}`
	`7001`
0	`7002`	`if (is8_10_12bitSwFormatsVaapi)`
	`7003`	`{`
0	`7004`	`if (string.Equals("hevc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`7005`	`\|\| string.Equals("h265", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`7006`	`{`
0	`7007`	`return GetHwaccelType(state, options, "hevc", bitDepth, hwSurface);`
	`7008`	`}`
	`7009`	`}`
	`7010`
0	`7011`	`return null;`
	`7012`	`}`
	`7013`
	`7014`	`public string GetVideotoolboxVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream,`
	`7015`	`{`
0	`7016`	`if (!OperatingSystem.IsMacOS()`
0	`7017`	`\|\| options.HardwareAccelerationType != HardwareAccelerationType.videotoolbox)`
	`7018`	`{`
0	`7019`	`return null;`
	`7020`	`}`
	`7021`
0	`7022`	`var is8bitSwFormatsVt = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase`
0	`7023`	`\|\| string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgnore`
0	`7024`	`var is8_10bitSwFormatsVt = is8bitSwFormatsVt \|\| string.Equals("yuv420p10le", videoStream.PixelFormat, String`
0	`7025`	`var is8_10_12bitSwFormatsVt = is8_10bitSwFormatsVt`
0	`7026`	`\|\| string.Equals("yuv422p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`7027`	`\|\| string.Equals("yuv444p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`7028`	`\|\| string.Equals("yuv422p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`7029`	`\|\| string.Equals("yuv444p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`7030`	`\|\| string.Equals("yuv420p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`7031`	`\|\| string.Equals("yuv422p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)`
0	`7032`	`\|\| string.Equals("yuv444p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase);`
0	`7033`	`var isAv1SupportedSwFormatsVt = is8_10bitSwFormatsVt \|\| string.Equals("yuv420p12le", videoStream.PixelFormat`
	`7034`
	`7035`	`// The related patches make videotoolbox hardware surface working is only available in jellyfin-ffmpeg 7.0.1`
0	`7036`	`bool useHwSurface = (_mediaEncoder.EncoderVersion >= _minFFmpegWorkingVtHwSurface) && IsVideoToolboxFullSupp`
	`7037`
0	`7038`	`if (is8bitSwFormatsVt)`
	`7039`	`{`
0	`7040`	`if (string.Equals("vp8", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`7041`	`{`
0	`7042`	`return GetHwaccelType(state, options, "vp8", bitDepth, useHwSurface);`
	`7043`	`}`
	`7044`	`}`
	`7045`
0	`7046`	`if (is8_10bitSwFormatsVt)`
	`7047`	`{`
0	`7048`	`if (string.Equals("avc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`7049`	`\|\| string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`7050`	`{`
0	`7051`	`return GetHwaccelType(state, options, "h264", bitDepth, useHwSurface);`
	`7052`	`}`
	`7053`
0	`7054`	`if (string.Equals("vp9", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`7055`	`{`
0	`7056`	`return GetHwaccelType(state, options, "vp9", bitDepth, useHwSurface);`
	`7057`	`}`
	`7058`	`}`
	`7059`
0	`7060`	`if (is8_10_12bitSwFormatsVt)`
	`7061`	`{`
0	`7062`	`if (string.Equals("hevc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`7063`	`\|\| string.Equals("h265", videoStream.Codec, StringComparison.OrdinalIgnoreCase))`
	`7064`	`{`
0	`7065`	`return GetHwaccelType(state, options, "hevc", bitDepth, useHwSurface);`
	`7066`	`}`
	`7067`
0	`7068`	`if (string.Equals("av1", videoStream.Codec, StringComparison.OrdinalIgnoreCase)`
0	`7069`	`&& isAv1SupportedSwFormatsVt`
0	`7070`	`&& _mediaEncoder.IsVideoToolboxAv1DecodeAvailable)`
	`7071`	`{`
0	`7072`	`return GetHwaccelType(state, options, "av1", bitDepth, useHwSurface);`
	`7073`	`}`
	`7074`	`}`
	`7075`
0	`7076`	`return null;`
	`7077`	`}`
	`7078`
	`7079`	`public string GetRkmppVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bi`
	`7080`	`{`
0	`7081`	`var isLinux = OperatingSystem.IsLinux();`
	`7082`
0	`7083`	`if (!isLinux`
0	`7084`	`\|\| options.HardwareAccelerationType != HardwareAccelerationType.rkmpp)`
	`7085`	`{`
0	`7086`	`return null;`
	`7087`	`}`
	`7088`
0	`7089`	`var inW = state.VideoStream?.Width;`
0	`7090`	`var inH = state.VideoStream?.Height;`
0	`7091`	`var reqW = state.BaseRequest.Width;`
0	`7092`	`var reqH = state.BaseRequest.Height;`
0	`7093`	`var reqMaxW = state.BaseRequest.MaxWidth;`
0	`7094`	`var reqMaxH = state.BaseRequest.MaxHeight;`
	`7095`
	`7096`	`// rkrga RGA2e supports range from 1/16 to 16`
0	`7097`	`if (!IsScaleRatioSupported(inW, inH, reqW, reqH, reqMaxW, reqMaxH, 16.0f))`
	`7098`	`{`
0	`7099`	`return null;`
	`7100`	`}`
	`7101`
0	`7102`	`var isRkmppOclSupported = IsRkmppFullSupported() && IsOpenclFullSupported();`
0	`7103`	`var hwSurface = isRkmppOclSupported`
0	`7104`	`&& _mediaEncoder.SupportsFilter("alphasrc");`
	`7105`
	`7106`	`// rkrga RGA3 supports range from 1/8 to 8`
0	`7107`	`var isAfbcSupported = hwSurface && IsScaleRatioSupported(inW, inH, reqW, reqH, reqMaxW, reqMaxH, 8.0f);`
	`7108`
	`7109`	`// TODO: add more 8/10bit and 4:2:2 formats for Rkmpp after finishing the ffcheck tool`
0	`7110`	`var is8bitSwFormatsRkmpp = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreC`
0	`7111`	`\|\| string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgn`
0	`7112`	`var is10bitSwFormatsRkmpp = string.Equals("yuv420p10le", videoStream.PixelFormat, StringComparison.OrdinalIg`
0	`7113`	`var is8_10bitSwFormatsRkmpp = is8bitSwFormatsRkmpp \|\| is10bitSwFormatsRkmpp;`
	`7114`
	`7115`	`// nv15 and nv20 are bit-stream only formats`
0	`7116`	`if (is10bitSwFormatsRkmpp && !hwSurface)`
	`7117`	`{`
0	`7118`	`return null;`
	`7119`	`}`
	`7120`
0	`7121`	`if (is8bitSwFormatsRkmpp)`
	`7122`	`{`
0	`7123`	`if (string.Equals(videoStream.Codec, "mpeg1video", StringComparison.OrdinalIgnoreCase))`
	`7124`	`{`
0	`7125`	`return GetHwaccelType(state, options, "mpeg1video", bitDepth, hwSurface);`
	`7126`	`}`
	`7127`
0	`7128`	`if (string.Equals(videoStream.Codec, "mpeg2video", StringComparison.OrdinalIgnoreCase))`
	`7129`	`{`
0	`7130`	`return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface);`
	`7131`	`}`
	`7132`
0	`7133`	`if (string.Equals(videoStream.Codec, "mpeg4", StringComparison.OrdinalIgnoreCase))`
	`7134`	`{`
0	`7135`	`return GetHwaccelType(state, options, "mpeg4", bitDepth, hwSurface);`
	`7136`	`}`
	`7137`
0	`7138`	`if (string.Equals(videoStream.Codec, "vp8", StringComparison.OrdinalIgnoreCase))`
	`7139`	`{`
0	`7140`	`return GetHwaccelType(state, options, "vp8", bitDepth, hwSurface);`
	`7141`	`}`
	`7142`	`}`
	`7143`
0	`7144`	`if (is8_10bitSwFormatsRkmpp)`
	`7145`	`{`
0	`7146`	`if (string.Equals(videoStream.Codec, "avc", StringComparison.OrdinalIgnoreCase)`
0	`7147`	`\|\| string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase))`
	`7148`	`{`
0	`7149`	`var accelType = GetHwaccelType(state, options, "h264", bitDepth, hwSurface);`
0	`7150`	`return accelType + ((!string.IsNullOrEmpty(accelType) && isAfbcSupported) ? " -afbc rga" : string.Em`
	`7151`	`}`
	`7152`
0	`7153`	`if (string.Equals(videoStream.Codec, "hevc", StringComparison.OrdinalIgnoreCase)`
0	`7154`	`\|\| string.Equals(videoStream.Codec, "h265", StringComparison.OrdinalIgnoreCase))`
	`7155`	`{`
0	`7156`	`var accelType = GetHwaccelType(state, options, "hevc", bitDepth, hwSurface);`
0	`7157`	`return accelType + ((!string.IsNullOrEmpty(accelType) && isAfbcSupported) ? " -afbc rga" : string.Em`
	`7158`	`}`
	`7159`
0	`7160`	`if (string.Equals(videoStream.Codec, "vp9", StringComparison.OrdinalIgnoreCase))`
	`7161`	`{`
0	`7162`	`var accelType = GetHwaccelType(state, options, "vp9", bitDepth, hwSurface);`
0	`7163`	`return accelType + ((!string.IsNullOrEmpty(accelType) && isAfbcSupported) ? " -afbc rga" : string.Em`
	`7164`	`}`
	`7165`
0	`7166`	`if (string.Equals(videoStream.Codec, "av1", StringComparison.OrdinalIgnoreCase))`
	`7167`	`{`
	`7168`	`// there's an issue about AV1 AFBC on RK3588, disable it for now until it's fixed upstream`
0	`7169`	`return GetHwaccelType(state, options, "av1", bitDepth, hwSurface);`
	`7170`	`}`
	`7171`	`}`
	`7172`
0	`7173`	`return null;`
	`7174`	`}`
	`7175`
	`7176`	`/// <summary>`
	`7177`	`/// Gets the number of threads.`
	`7178`	`/// </summary>`
	`7179`	`/// <param name="state">Encoding state.</param>`
	`7180`	`/// <param name="encodingOptions">Encoding options.</param>`
	`7181`	`/// <param name="outputVideoCodec">Video codec to use.</param>`
	`7182`	`/// <returns>Number of threads.</returns>`
	`7183`	`#nullable enable`
	`7184`	`public static int GetNumberOfThreads(EncodingJobInfo? state, EncodingOptions encodingOptions, string? outputVide`
	`7185`	`{`
0	`7186`	`var threads = state?.BaseRequest.CpuCoreLimit ?? encodingOptions.EncodingThreadCount;`
	`7187`
0	`7188`	`if (threads <= 0)`
	`7189`	`{`
	`7190`	`// Automatically set thread count`
0	`7191`	`return 0;`
	`7192`	`}`
	`7193`
0	`7194`	`return Math.Min(threads, Environment.ProcessorCount);`
	`7195`	`}`
	`7196`
	`7197`	`#nullable disable`
	`7198`	`public void TryStreamCopy(EncodingJobInfo state, EncodingOptions options)`
	`7199`	`{`
0	`7200`	`if (state.VideoStream is not null && CanStreamCopyVideo(state, state.VideoStream))`
	`7201`	`{`
0	`7202`	`state.OutputVideoCodec = "copy";`
	`7203`	`}`
	`7204`	`else`
	`7205`	`{`
0	`7206`	`var user = state.User;`
	`7207`
	`7208`	`// If the user doesn't have access to transcoding, then force stream copy, regardless of whether it will`
0	`7209`	`if (user is not null && !user.HasPermission(PermissionKind.EnableVideoPlaybackTranscoding))`
	`7210`	`{`
0	`7211`	`state.OutputVideoCodec = "copy";`
	`7212`	`}`
	`7213`	`}`
	`7214`
0	`7215`	`var preventHlsAudioCopy = state.TranscodingType is TranscodingJobType.Hls`
0	`7216`	`&& state.VideoStream is not null`
0	`7217`	`&& !IsCopyCodec(state.OutputVideoCodec)`
0	`7218`	`&& options.HlsAudioSeekStrategy is HlsAudioSeekStrategy.TranscodeAudio;`
	`7219`
0	`7220`	`if (state.AudioStream is not null`
0	`7221`	`&& CanStreamCopyAudio(state, state.AudioStream, state.SupportedAudioCodecs)`
0	`7222`	`&& !preventHlsAudioCopy)`
	`7223`	`{`
0	`7224`	`state.OutputAudioCodec = "copy";`
	`7225`	`}`
	`7226`	`else`
	`7227`	`{`
0	`7228`	`var user = state.User;`
	`7229`
	`7230`	`// If the user doesn't have access to transcoding, then force stream copy, regardless of whether it will`
0	`7231`	`if (user is not null && !user.HasPermission(PermissionKind.EnableAudioPlaybackTranscoding))`
	`7232`	`{`
0	`7233`	`state.OutputAudioCodec = "copy";`
	`7234`	`}`
	`7235`	`}`
0	`7236`	`}`
	`7237`
	`7238`	`private string GetFfmpegAnalyzeDurationArg(EncodingJobInfo state)`
	`7239`	`{`
4	`7240`	`var analyzeDurationArgument = string.Empty;`
	`7241`
	`7242`	`// Apply -analyzeduration as per the environment variable,`
	`7243`	`// otherwise ffmpeg will break on certain files due to default value is 0.`
4	`7244`	`var ffmpegAnalyzeDuration = _config.GetFFmpegAnalyzeDuration() ?? string.Empty;`
	`7245`
4	`7246`	`if (state.MediaSource.AnalyzeDurationMs > 0)`
	`7247`	`{`
0	`7248`	`analyzeDurationArgument = "-analyzeduration " + (state.MediaSource.AnalyzeDurationMs.Value * 1000).ToStr`
	`7249`	`}`
4	`7250`	`else if (!string.IsNullOrEmpty(ffmpegAnalyzeDuration))`
	`7251`	`{`
0	`7252`	`analyzeDurationArgument = "-analyzeduration " + ffmpegAnalyzeDuration;`
	`7253`	`}`
	`7254`
4	`7255`	`return analyzeDurationArgument;`
	`7256`	`}`
	`7257`
	`7258`	`private string GetFfmpegProbesizeArg()`
	`7259`	`{`
4	`7260`	`var ffmpegProbeSize = _config.GetFFmpegProbeSize();`
	`7261`
4	`7262`	`if (!string.IsNullOrEmpty(ffmpegProbeSize))`
	`7263`	`{`
0	`7264`	`return $"-probesize {ffmpegProbeSize}";`
	`7265`	`}`
	`7266`
4	`7267`	`return string.Empty;`
	`7268`	`}`
	`7269`
	`7270`	`public string GetInputModifier(EncodingJobInfo state, EncodingOptions encodingOptions, string segmentContainer)`
	`7271`	`{`
0	`7272`	`var inputModifier = string.Empty;`
0	`7273`	`var analyzeDurationArgument = GetFfmpegAnalyzeDurationArg(state);`
	`7274`
0	`7275`	`if (!string.IsNullOrEmpty(analyzeDurationArgument))`
	`7276`	`{`
0	`7277`	`inputModifier += " " + analyzeDurationArgument;`
	`7278`	`}`
	`7279`
0	`7280`	`inputModifier = inputModifier.Trim();`
	`7281`
	`7282`	`// Apply -probesize if configured`
0	`7283`	`var ffmpegProbeSizeArgument = GetFfmpegProbesizeArg();`
	`7284`
0	`7285`	`if (!string.IsNullOrEmpty(ffmpegProbeSizeArgument))`
	`7286`	`{`
0	`7287`	`inputModifier += " " + ffmpegProbeSizeArgument;`
	`7288`	`}`
	`7289`
0	`7290`	`var userAgentParam = GetUserAgentParam(state);`
	`7291`
0	`7292`	`if (!string.IsNullOrEmpty(userAgentParam))`
	`7293`	`{`
0	`7294`	`inputModifier += " " + userAgentParam;`
	`7295`	`}`
	`7296`
0	`7297`	`inputModifier = inputModifier.Trim();`
	`7298`
0	`7299`	`var refererParam = GetRefererParam(state);`
	`7300`
0	`7301`	`if (!string.IsNullOrEmpty(refererParam))`
	`7302`	`{`
0	`7303`	`inputModifier += " " + refererParam;`
	`7304`	`}`
	`7305`
0	`7306`	`inputModifier = inputModifier.Trim();`
	`7307`
0	`7308`	`inputModifier += " " + GetFastSeekCommandLineParameter(state, encodingOptions, segmentContainer);`
0	`7309`	`inputModifier = inputModifier.Trim();`
	`7310`
0	`7311`	`if (state.InputProtocol == MediaProtocol.Rtsp)`
	`7312`	`{`
0	`7313`	`inputModifier += " -rtsp_transport tcp+udp -rtsp_flags prefer_tcp";`
	`7314`	`}`
	`7315`
0	`7316`	`if (!string.IsNullOrEmpty(state.InputAudioSync))`
	`7317`	`{`
0	`7318`	`inputModifier += " -async " + state.InputAudioSync;`
	`7319`	`}`
	`7320`
	`7321`	`// The -fps_mode option cannot be applied to input`
0	`7322`	`if (!string.IsNullOrEmpty(state.InputVideoSync) && _mediaEncoder.EncoderVersion < new Version(5, 1))`
	`7323`	`{`
0	`7324`	`inputModifier += GetVideoSyncOption(state.InputVideoSync, _mediaEncoder.EncoderVersion);`
	`7325`	`}`
	`7326`
0	`7327`	`int readrate = 0;`
0	`7328`	`if (state.ReadInputAtNativeFramerate && state.InputProtocol != MediaProtocol.Rtsp)`
	`7329`	`{`
0	`7330`	`readrate = 1;`
0	`7331`	`inputModifier += " -re";`
	`7332`	`}`
0	`7333`	`else if (encodingOptions.EnableSegmentDeletion`
0	`7334`	`&& state.VideoStream is not null`
0	`7335`	`&& state.TranscodingType == TranscodingJobType.Hls`
0	`7336`	`&& IsCopyCodec(state.OutputVideoCodec)`
0	`7337`	`&& _mediaEncoder.EncoderVersion >= _minFFmpegReadrateOption)`
	`7338`	`{`
	`7339`	`// Set an input read rate limit 10x for using SegmentDeletion with stream-copy`
	`7340`	`// to prevent ffmpeg from exiting prematurely (due to fast drive)`
0	`7341`	`readrate = 10;`
0	`7342`	`inputModifier += $" -readrate {readrate}";`
	`7343`	`}`
	`7344`
	`7345`	`// Set a larger catchup value to revert to the old behavior,`
	`7346`	`// otherwise, remuxing might stall due to this new option`
0	`7347`	`if (readrate > 0 && _mediaEncoder.EncoderVersion >= _minFFmpegReadrateCatchupOption)`
	`7348`	`{`
0	`7349`	`inputModifier += $" -readrate_catchup {readrate * 100}";`
	`7350`	`}`
	`7351`
0	`7352`	`var flags = new List<string>();`
0	`7353`	`if (state.IgnoreInputDts)`
	`7354`	`{`
0	`7355`	`flags.Add("+igndts");`
	`7356`	`}`
	`7357`
0	`7358`	`if (state.IgnoreInputIndex)`
	`7359`	`{`
0	`7360`	`flags.Add("+ignidx");`
	`7361`	`}`
	`7362`
0	`7363`	`if (state.GenPtsInput \|\| IsCopyCodec(state.OutputVideoCodec))`
	`7364`	`{`
0	`7365`	`flags.Add("+genpts");`
	`7366`	`}`
	`7367`
0	`7368`	`if (state.DiscardCorruptFramesInput)`
	`7369`	`{`
0	`7370`	`flags.Add("+discardcorrupt");`
	`7371`	`}`
	`7372`
0	`7373`	`if (state.EnableFastSeekInput)`
	`7374`	`{`
0	`7375`	`flags.Add("+fastseek");`
	`7376`	`}`
	`7377`
0	`7378`	`if (flags.Count > 0)`
	`7379`	`{`
0	`7380`	`inputModifier += " -fflags " + string.Join(string.Empty, flags);`
	`7381`	`}`
	`7382`
0	`7383`	`if (state.IsVideoRequest)`
	`7384`	`{`
0	`7385`	`if (!string.IsNullOrEmpty(state.InputContainer) && state.VideoType == VideoType.VideoFile && encodingOpt`
	`7386`	`{`
0	`7387`	`var inputFormat = GetInputFormat(state.InputContainer);`
0	`7388`	`if (!string.IsNullOrEmpty(inputFormat))`
	`7389`	`{`
0	`7390`	`inputModifier += " -f " + inputFormat;`
	`7391`	`}`
	`7392`	`}`
	`7393`	`}`
	`7394`
0	`7395`	`if (state.MediaSource.RequiresLooping)`
	`7396`	`{`
0	`7397`	`inputModifier += " -stream_loop -1 -reconnect_at_eof 1 -reconnect_streamed 1 -reconnect_delay_max 2";`
	`7398`	`}`
	`7399`
0	`7400`	`return inputModifier;`
	`7401`	`}`
	`7402`
	`7403`	`public void AttachMediaSourceInfo(`
	`7404`	`EncodingJobInfo state,`
	`7405`	`EncodingOptions encodingOptions,`
	`7406`	`MediaSourceInfo mediaSource,`
	`7407`	`string requestedUrl)`
	`7408`	`{`
0	`7409`	`ArgumentNullException.ThrowIfNull(state);`
	`7410`
0	`7411`	`ArgumentNullException.ThrowIfNull(mediaSource);`
	`7412`
0	`7413`	`var path = mediaSource.Path;`
0	`7414`	`var protocol = mediaSource.Protocol;`
	`7415`
0	`7416`	`if (!string.IsNullOrEmpty(mediaSource.EncoderPath) && mediaSource.EncoderProtocol.HasValue)`
	`7417`	`{`
0	`7418`	`path = mediaSource.EncoderPath;`
0	`7419`	`protocol = mediaSource.EncoderProtocol.Value;`
	`7420`	`}`
	`7421`
0	`7422`	`state.MediaPath = path;`
0	`7423`	`state.InputProtocol = protocol;`
0	`7424`	`state.InputContainer = mediaSource.Container;`
0	`7425`	`state.RunTimeTicks = mediaSource.RunTimeTicks;`
0	`7426`	`state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;`
	`7427`
0	`7428`	`state.IsoType = mediaSource.IsoType;`
	`7429`
0	`7430`	`if (mediaSource.Timestamp.HasValue)`
	`7431`	`{`
0	`7432`	`state.InputTimestamp = mediaSource.Timestamp.Value;`
	`7433`	`}`
	`7434`
0	`7435`	`state.RunTimeTicks = mediaSource.RunTimeTicks;`
0	`7436`	`state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;`
0	`7437`	`state.ReadInputAtNativeFramerate = mediaSource.ReadAtNativeFramerate;`
	`7438`
0	`7439`	`if ((state.ReadInputAtNativeFramerate && !state.IsSegmentedLiveStream)`
0	`7440`	`\|\| (mediaSource.Protocol == MediaProtocol.File`
0	`7441`	`&& string.Equals(mediaSource.Container, "wtv", StringComparison.OrdinalIgnoreCase)))`
	`7442`	`{`
0	`7443`	`state.InputVideoSync = "-1";`
0	`7444`	`state.InputAudioSync = "1";`
	`7445`	`}`
	`7446`
0	`7447`	`if (string.Equals(mediaSource.Container, "wma", StringComparison.OrdinalIgnoreCase)`
0	`7448`	`\|\| string.Equals(mediaSource.Container, "asf", StringComparison.OrdinalIgnoreCase))`
	`7449`	`{`
	`7450`	`// Seeing some stuttering when transcoding wma to audio-only HLS`
0	`7451`	`state.InputAudioSync = "1";`
	`7452`	`}`
	`7453`
0	`7454`	`var mediaStreams = mediaSource.MediaStreams;`
	`7455`
0	`7456`	`if (state.IsVideoRequest)`
	`7457`	`{`
0	`7458`	`var videoRequest = state.BaseRequest;`
	`7459`
0	`7460`	`if (string.IsNullOrEmpty(videoRequest.VideoCodec))`
	`7461`	`{`
0	`7462`	`if (string.IsNullOrEmpty(requestedUrl))`
	`7463`	`{`
0	`7464`	`requestedUrl = "test." + videoRequest.Container;`
	`7465`	`}`
	`7466`
0	`7467`	`videoRequest.VideoCodec = InferVideoCodec(requestedUrl);`
	`7468`	`}`
	`7469`
0	`7470`	`state.VideoStream = GetMediaStream(mediaStreams, videoRequest.VideoStreamIndex, MediaStreamType.Video);`
0	`7471`	`state.SubtitleStream = GetMediaStream(mediaStreams, videoRequest.SubtitleStreamIndex, MediaStreamType.Su`
0	`7472`	`state.SubtitleDeliveryMethod = videoRequest.SubtitleMethod;`
0	`7473`	`state.AudioStream = GetMediaStream(mediaStreams, videoRequest.AudioStreamIndex, MediaStreamType.Audio);`
	`7474`
0	`7475`	`if (state.SubtitleStream is not null && !state.SubtitleStream.IsExternal)`
	`7476`	`{`
0	`7477`	`state.InternalSubtitleStreamOffset = mediaStreams.Where(i => i.Type == MediaStreamType.Subtitle && !`
	`7478`	`}`
	`7479`
0	`7480`	`EnforceResolutionLimit(state);`
	`7481`
0	`7482`	`NormalizeSubtitleEmbed(state);`
	`7483`	`}`
	`7484`	`else`
	`7485`	`{`
0	`7486`	`state.AudioStream = GetMediaStream(mediaStreams, null, MediaStreamType.Audio, true);`
	`7487`	`}`
	`7488`
0	`7489`	`state.MediaSource = mediaSource;`
	`7490`
0	`7491`	`var request = state.BaseRequest;`
0	`7492`	`var supportedAudioCodecs = state.SupportedAudioCodecs;`
0	`7493`	`if (request is not null && supportedAudioCodecs is not null && supportedAudioCodecs.Length > 0)`
	`7494`	`{`
0	`7495`	`var supportedAudioCodecsList = supportedAudioCodecs.ToList();`
	`7496`
0	`7497`	`ShiftAudioCodecsIfNeeded(supportedAudioCodecsList, state.AudioStream);`
	`7498`
0	`7499`	`state.SupportedAudioCodecs = supportedAudioCodecsList.ToArray();`
	`7500`
0	`7501`	`request.AudioCodec = state.SupportedAudioCodecs.FirstOrDefault(_mediaEncoder.CanEncodeToAudioCodec)`
0	`7502`	`?? state.SupportedAudioCodecs.FirstOrDefault();`
	`7503`	`}`
	`7504`
0	`7505`	`var supportedVideoCodecs = state.SupportedVideoCodecs;`
0	`7506`	`if (request is not null && supportedVideoCodecs is not null && supportedVideoCodecs.Length > 0)`
	`7507`	`{`
0	`7508`	`var supportedVideoCodecsList = supportedVideoCodecs.ToList();`
	`7509`
0	`7510`	`ShiftVideoCodecsIfNeeded(supportedVideoCodecsList, encodingOptions);`
	`7511`
0	`7512`	`state.SupportedVideoCodecs = supportedVideoCodecsList.ToArray();`
	`7513`
0	`7514`	`request.VideoCodec = state.SupportedVideoCodecs.FirstOrDefault();`
	`7515`	`}`
0	`7516`	`}`
	`7517`
	`7518`	`private void ShiftAudioCodecsIfNeeded(List<string> audioCodecs, MediaStream audioStream)`
	`7519`	`{`
	`7520`	`// No need to shift if there is only one supported audio codec.`
0	`7521`	`if (audioCodecs.Count < 2)`
	`7522`	`{`
0	`7523`	`return;`
	`7524`	`}`
	`7525`
0	`7526`	`var inputChannels = audioStream is null ? 6 : audioStream.Channels ?? 6;`
0	`7527`	`var shiftAudioCodecs = new List<string>();`
0	`7528`	`if (inputChannels >= 6)`
	`7529`	`{`
	`7530`	`// DTS and TrueHD are not supported by HLS`
	`7531`	`// Keep them in the supported codecs list, but shift them to the end of the list so that if transcoding`
0	`7532`	`shiftAudioCodecs.Add("dts");`
0	`7533`	`shiftAudioCodecs.Add("truehd");`
	`7534`	`}`
	`7535`	`else`
	`7536`	`{`
	`7537`	`// Transcoding to 2ch ac3 or eac3 almost always causes a playback failure`
	`7538`	`// Keep them in the supported codecs list, but shift them to the end of the list so that if transcoding`
0	`7539`	`shiftAudioCodecs.Add("ac3");`
0	`7540`	`shiftAudioCodecs.Add("eac3");`
	`7541`	`}`
	`7542`
0	`7543`	`if (audioCodecs.All(i => shiftAudioCodecs.Contains(i, StringComparison.OrdinalIgnoreCase)))`
	`7544`	`{`
0	`7545`	`return;`
	`7546`	`}`
	`7547`
0	`7548`	`while (shiftAudioCodecs.Contains(audioCodecs[0], StringComparison.OrdinalIgnoreCase))`
	`7549`	`{`
0	`7550`	`var removed = audioCodecs[0];`
0	`7551`	`audioCodecs.RemoveAt(0);`
0	`7552`	`audioCodecs.Add(removed);`
	`7553`	`}`
0	`7554`	`}`
	`7555`
	`7556`	`private void ShiftVideoCodecsIfNeeded(List<string> videoCodecs, EncodingOptions encodingOptions)`
	`7557`	`{`
	`7558`	`// No need to shift if there is only one supported video codec.`
0	`7559`	`if (videoCodecs.Count < 2)`
	`7560`	`{`
0	`7561`	`return;`
	`7562`	`}`
	`7563`
	`7564`	`// Shift codecs to the end of list if it's not allowed.`
0	`7565`	`var shiftVideoCodecs = new List<string>();`
0	`7566`	`if (!encodingOptions.AllowHevcEncoding)`
	`7567`	`{`
0	`7568`	`shiftVideoCodecs.Add("hevc");`
0	`7569`	`shiftVideoCodecs.Add("h265");`
	`7570`	`}`
	`7571`
0	`7572`	`if (!encodingOptions.AllowAv1Encoding)`
	`7573`	`{`
0	`7574`	`shiftVideoCodecs.Add("av1");`
	`7575`	`}`
	`7576`
0	`7577`	`if (videoCodecs.All(i => shiftVideoCodecs.Contains(i, StringComparison.OrdinalIgnoreCase)))`
	`7578`	`{`
0	`7579`	`return;`
	`7580`	`}`
	`7581`
0	`7582`	`while (shiftVideoCodecs.Contains(videoCodecs[0], StringComparison.OrdinalIgnoreCase))`
	`7583`	`{`
0	`7584`	`var removed = videoCodecs[0];`
0	`7585`	`videoCodecs.RemoveAt(0);`
0	`7586`	`videoCodecs.Add(removed);`
	`7587`	`}`
0	`7588`	`}`
	`7589`
	`7590`	`private void NormalizeSubtitleEmbed(EncodingJobInfo state)`
	`7591`	`{`
0	`7592`	`if (state.SubtitleStream is null \|\| state.SubtitleDeliveryMethod != SubtitleDeliveryMethod.Embed)`
	`7593`	`{`
0	`7594`	`return;`
	`7595`	`}`
	`7596`
	`7597`	`// This is tricky to remux in, after converting to dvdsub it's not positioned correctly`
	`7598`	`// Therefore, let's just burn it in`
0	`7599`	`if (string.Equals(state.SubtitleStream.Codec, "DVBSUB", StringComparison.OrdinalIgnoreCase))`
	`7600`	`{`
0	`7601`	`state.SubtitleDeliveryMethod = SubtitleDeliveryMethod.Encode;`
	`7602`	`}`
0	`7603`	`}`
	`7604`
	`7605`	`public string GetSubtitleEmbedArguments(EncodingJobInfo state)`
	`7606`	`{`
0	`7607`	`if (state.SubtitleStream is null \|\| state.SubtitleDeliveryMethod != SubtitleDeliveryMethod.Embed)`
	`7608`	`{`
0	`7609`	`return string.Empty;`
	`7610`	`}`
	`7611`
0	`7612`	`var format = state.SupportedSubtitleCodecs.FirstOrDefault();`
	`7613`	`string codec;`
	`7614`
0	`7615`	`if (string.IsNullOrEmpty(format) \|\| string.Equals(format, state.SubtitleStream.Codec, StringComparison.Ordin`
	`7616`	`{`
0	`7617`	`codec = "copy";`
	`7618`	`}`
	`7619`	`else`
	`7620`	`{`
0	`7621`	`codec = format;`
	`7622`	`}`
	`7623`
0	`7624`	`return " -codec:s:0 " + codec + " -disposition:s:0 default";`
	`7625`	`}`
	`7626`
	`7627`	`public string GetProgressiveVideoFullCommandLine(EncodingJobInfo state, EncodingOptions encodingOptions, Encoder`
	`7628`	`{`
	`7629`	`// Get the output codec name`
0	`7630`	`var videoCodec = GetVideoEncoder(state, encodingOptions);`
	`7631`
0	`7632`	`var format = string.Empty;`
0	`7633`	`var keyFrame = string.Empty;`
0	`7634`	`var outputPath = state.OutputFilePath;`
	`7635`
0	`7636`	`if (Path.GetExtension(outputPath.AsSpan()).Equals(".mp4", StringComparison.OrdinalIgnoreCase)`
0	`7637`	`&& state.BaseRequest.Context == EncodingContext.Streaming)`
	`7638`	`{`
	`7639`	`// Comparison: https://github.com/jansmolders86/mediacenterjs/blob/master/lib/transcoding/desktop.js`
0	`7640`	`format = " -f mp4 -movflags frag_keyframe+empty_moov+delay_moov";`
	`7641`	`}`
	`7642`
0	`7643`	`var threads = GetNumberOfThreads(state, encodingOptions, videoCodec);`
	`7644`
0	`7645`	`var inputModifier = GetInputModifier(state, encodingOptions, null);`
	`7646`
0	`7647`	`return string.Format(`
0	`7648`	`CultureInfo.InvariantCulture,`
0	`7649`	`"{0} {1}{2} {3} {4} -map_metadata -1 -map_chapters -1 -threads {5} {6}{7}{8} -y \"{9}\"",`
0	`7650`	`inputModifier,`
0	`7651`	`GetInputArgument(state, encodingOptions, null),`
0	`7652`	`keyFrame,`
0	`7653`	`GetMapArgs(state),`
0	`7654`	`GetProgressiveVideoArguments(state, encodingOptions, videoCodec, defaultPreset),`
0	`7655`	`threads,`
0	`7656`	`GetProgressiveVideoAudioArguments(state, encodingOptions),`
0	`7657`	`GetSubtitleEmbedArguments(state),`
0	`7658`	`format,`
0	`7659`	`outputPath).Trim();`
	`7660`	`}`
	`7661`
	`7662`	`public string GetOutputFFlags(EncodingJobInfo state)`
	`7663`	`{`
0	`7664`	`var flags = new List<string>();`
0	`7665`	`if (state.GenPtsOutput)`
	`7666`	`{`
0	`7667`	`flags.Add("+genpts");`
	`7668`	`}`
	`7669`
0	`7670`	`if (flags.Count > 0)`
	`7671`	`{`
0	`7672`	`return " -fflags " + string.Join(string.Empty, flags);`
	`7673`	`}`
	`7674`
0	`7675`	`return string.Empty;`
	`7676`	`}`
	`7677`
	`7678`	`public string GetProgressiveVideoArguments(EncodingJobInfo state, EncodingOptions encodingOptions, string videoC`
	`7679`	`{`
0	`7680`	`var args = "-codec:v:0 " + videoCodec;`
	`7681`
0	`7682`	`if (state.BaseRequest.EnableMpegtsM2TsMode)`
	`7683`	`{`
0	`7684`	`args += " -mpegts_m2ts_mode 1";`
	`7685`	`}`
	`7686`
0	`7687`	`if (IsCopyCodec(videoCodec))`
	`7688`	`{`
0	`7689`	`if (state.VideoStream is not null`
0	`7690`	`&& string.Equals(state.OutputContainer, "ts", StringComparison.OrdinalIgnoreCase)`
0	`7691`	`&& !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase))`
	`7692`	`{`
0	`7693`	`string bitStreamArgs = GetBitStreamArgs(state, MediaStreamType.Video);`
0	`7694`	`if (!string.IsNullOrEmpty(bitStreamArgs))`
	`7695`	`{`
0	`7696`	`args += " " + bitStreamArgs;`
	`7697`	`}`
	`7698`	`}`
	`7699`
0	`7700`	`if (state.RunTimeTicks.HasValue && state.BaseRequest.CopyTimestamps)`
	`7701`	`{`
0	`7702`	`args += " -copyts -avoid_negative_ts disabled -start_at_zero";`
	`7703`	`}`
	`7704`
0	`7705`	`if (!state.RunTimeTicks.HasValue)`
	`7706`	`{`
0	`7707`	`args += " -fflags +genpts";`
	`7708`	`}`
	`7709`	`}`
	`7710`	`else`
	`7711`	`{`
0	`7712`	`var keyFrameArg = string.Format(`
0	`7713`	`CultureInfo.InvariantCulture,`
0	`7714`	`" -force_key_frames \"expr:gte(t,n_forced*{0})\"",`
0	`7715`	`5);`
	`7716`
0	`7717`	`args += keyFrameArg;`
	`7718`
0	`7719`	`var hasGraphicalSubs = state.SubtitleStream is not null && !state.SubtitleStream.IsTextSubtitleStream &&`
	`7720`
0	`7721`	`var hasCopyTs = false;`
	`7722`
	`7723`	`// video processing filters.`
0	`7724`	`var videoProcessParam = GetVideoProcessingFilterParam(state, encodingOptions, videoCodec);`
	`7725`
0	`7726`	`var negativeMapArgs = GetNegativeMapArgsByFilters(state, videoProcessParam);`
	`7727`
0	`7728`	`args = negativeMapArgs + args + videoProcessParam;`
	`7729`
0	`7730`	`hasCopyTs = videoProcessParam.Contains("copyts", StringComparison.OrdinalIgnoreCase);`
	`7731`
0	`7732`	`if (state.RunTimeTicks.HasValue && state.BaseRequest.CopyTimestamps)`
	`7733`	`{`
0	`7734`	`if (!hasCopyTs)`
	`7735`	`{`
0	`7736`	`args += " -copyts";`
	`7737`	`}`
	`7738`
0	`7739`	`args += " -avoid_negative_ts disabled";`
	`7740`
0	`7741`	`if (!(state.SubtitleStream is not null && state.SubtitleStream.IsExternal && !state.SubtitleStream.I`
	`7742`	`{`
0	`7743`	`args += " -start_at_zero";`
	`7744`	`}`
	`7745`	`}`
	`7746`
0	`7747`	`var qualityParam = GetVideoQualityParam(state, videoCodec, encodingOptions, defaultPreset);`
	`7748`
0	`7749`	`if (!string.IsNullOrEmpty(qualityParam))`
	`7750`	`{`
0	`7751`	`args += " " + qualityParam.Trim();`
	`7752`	`}`
	`7753`	`}`
	`7754`
0	`7755`	`if (!string.IsNullOrEmpty(state.OutputVideoSync))`
	`7756`	`{`
0	`7757`	`args += GetVideoSyncOption(state.OutputVideoSync, _mediaEncoder.EncoderVersion);`
	`7758`	`}`
	`7759`
0	`7760`	`args += GetOutputFFlags(state);`
	`7761`
0	`7762`	`return args;`
	`7763`	`}`
	`7764`
	`7765`	`public string GetProgressiveVideoAudioArguments(EncodingJobInfo state, EncodingOptions encodingOptions)`
	`7766`	`{`
	`7767`	`// If the video doesn't have an audio stream, return a default.`
0	`7768`	`if (state.AudioStream is null && state.VideoStream is not null)`
	`7769`	`{`
0	`7770`	`return string.Empty;`
	`7771`	`}`
	`7772`
	`7773`	`// Get the output codec name`
0	`7774`	`var codec = GetAudioEncoder(state);`
	`7775`
0	`7776`	`var args = "-codec:a:0 " + codec;`
	`7777`
0	`7778`	`if (IsCopyCodec(codec))`
	`7779`	`{`
0	`7780`	`return args;`
	`7781`	`}`
	`7782`
0	`7783`	`var channels = state.OutputAudioChannels;`
	`7784`
0	`7785`	`var useDownMixAlgorithm = state.AudioStream is not null`
0	`7786`	`&& DownMixAlgorithmsHelper.AlgorithmFilterStrings.ContainsKey((encodingOptions.Dow`
	`7787`
0	`7788`	`if (channels.HasValue && !useDownMixAlgorithm)`
	`7789`	`{`
0	`7790`	`args += " -ac " + channels.Value;`
	`7791`	`}`
	`7792`
0	`7793`	`var bitrate = state.OutputAudioBitrate;`
0	`7794`	`if (bitrate.HasValue && !LosslessAudioCodecs.Contains(codec, StringComparison.OrdinalIgnoreCase))`
	`7795`	`{`
0	`7796`	`var vbrParam = GetAudioVbrModeParam(codec, bitrate.Value, channels ?? 2);`
0	`7797`	`if (encodingOptions.EnableAudioVbr && state.EnableAudioVbrEncoding && vbrParam is not null)`
	`7798`	`{`
0	`7799`	`args += vbrParam;`
	`7800`	`}`
	`7801`	`else`
	`7802`	`{`
0	`7803`	`args += " -ab " + bitrate.Value.ToString(CultureInfo.InvariantCulture);`
	`7804`	`}`
	`7805`	`}`
	`7806`
0	`7807`	`if (state.OutputAudioSampleRate.HasValue)`
	`7808`	`{`
0	`7809`	`args += " -ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture);`
	`7810`	`}`
	`7811`
0	`7812`	`args += GetAudioFilterParam(state, encodingOptions);`
	`7813`
0	`7814`	`return args;`
	`7815`	`}`
	`7816`
	`7817`	`public string GetProgressiveAudioFullCommandLine(EncodingJobInfo state, EncodingOptions encodingOptions, string`
	`7818`	`{`
0	`7819`	`var audioTranscodeParams = new List<string>();`
	`7820`
0	`7821`	`var bitrate = state.OutputAudioBitrate;`
0	`7822`	`var channels = state.OutputAudioChannels;`
0	`7823`	`var outputCodec = state.OutputAudioCodec;`
	`7824`
0	`7825`	`if (bitrate.HasValue && !LosslessAudioCodecs.Contains(outputCodec, StringComparison.OrdinalIgnoreCase))`
	`7826`	`{`
0	`7827`	`var vbrParam = GetAudioVbrModeParam(GetAudioEncoder(state), bitrate.Value, channels ?? 2);`
0	`7828`	`if (encodingOptions.EnableAudioVbr && state.EnableAudioVbrEncoding && vbrParam is not null)`
	`7829`	`{`
0	`7830`	`audioTranscodeParams.Add(vbrParam);`
	`7831`	`}`
	`7832`	`else`
	`7833`	`{`
0	`7834`	`audioTranscodeParams.Add("-ab " + bitrate.Value.ToString(CultureInfo.InvariantCulture));`
	`7835`	`}`
	`7836`	`}`
	`7837`
0	`7838`	`if (channels.HasValue)`
	`7839`	`{`
0	`7840`	`audioTranscodeParams.Add("-ac " + state.OutputAudioChannels.Value.ToString(CultureInfo.InvariantCulture)`
	`7841`	`}`
	`7842`
0	`7843`	`if (!string.IsNullOrEmpty(outputCodec))`
	`7844`	`{`
0	`7845`	`audioTranscodeParams.Add("-acodec " + GetAudioEncoder(state));`
	`7846`	`}`
	`7847`
0	`7848`	`if (GetAudioEncoder(state).StartsWith("pcm_", StringComparison.Ordinal))`
	`7849`	`{`
0	`7850`	`audioTranscodeParams.Add(string.Concat("-f ", GetAudioEncoder(state).AsSpan(4)));`
0	`7851`	`audioTranscodeParams.Add("-ar " + state.BaseRequest.AudioBitRate);`
	`7852`	`}`
	`7853`
0	`7854`	`if (!string.Equals(outputCodec, "opus", StringComparison.OrdinalIgnoreCase))`
	`7855`	`{`
	`7856`	`// opus only supports specific sampling rates`
0	`7857`	`var sampleRate = state.OutputAudioSampleRate;`
0	`7858`	`if (sampleRate.HasValue)`
	`7859`	`{`
0	`7860`	`var sampleRateValue = sampleRate.Value switch`
0	`7861`	`{`
0	`7862`	`<= 8000 => 8000,`
0	`7863`	`<= 12000 => 12000,`
0	`7864`	`<= 16000 => 16000,`
0	`7865`	`<= 24000 => 24000,`
0	`7866`	`_ => 48000`
0	`7867`	`};`
	`7868`
0	`7869`	`audioTranscodeParams.Add("-ar " + sampleRateValue.ToString(CultureInfo.InvariantCulture));`
	`7870`	`}`
	`7871`	`}`
	`7872`
	`7873`	`// Copy the movflags from GetProgressiveVideoFullCommandLine`
	`7874`	`// See #9248 and the associated PR for why this is needed`
0	`7875`	`if (_mp4ContainerNames.Contains(state.OutputContainer))`
	`7876`	`{`
0	`7877`	`audioTranscodeParams.Add("-movflags empty_moov+delay_moov");`
	`7878`	`}`
	`7879`
0	`7880`	`var threads = GetNumberOfThreads(state, encodingOptions, null);`
	`7881`
0	`7882`	`var inputModifier = GetInputModifier(state, encodingOptions, null);`
	`7883`
0	`7884`	`return string.Format(`
0	`7885`	`CultureInfo.InvariantCulture,`
0	`7886`	`"{0} {1}{7}{8} -threads {2}{3} {4} -id3v2_version 3 -write_id3v1 1{6} -y \"{5}\"",`
0	`7887`	`inputModifier,`
0	`7888`	`GetInputArgument(state, encodingOptions, null),`
0	`7889`	`threads,`
0	`7890`	`" -vn",`
0	`7891`	`string.Join(' ', audioTranscodeParams),`
0	`7892`	`outputPath,`
0	`7893`	`string.Empty,`
0	`7894`	`string.Empty,`
0	`7895`	`string.Empty).Trim();`
	`7896`	`}`
	`7897`
	`7898`	`public static int FindIndex(IReadOnlyList<MediaStream> mediaStreams, MediaStream streamToFind)`
	`7899`	`{`
16	`7900`	`var index = 0;`
16	`7901`	`var length = mediaStreams.Count;`
	`7902`
56	`7903`	`for (var i = 0; i < length; i++)`
	`7904`	`{`
28	`7905`	`var currentMediaStream = mediaStreams[i];`
28	`7906`	`if (currentMediaStream == streamToFind)`
	`7907`	`{`
16	`7908`	`return index;`
	`7909`	`}`
	`7910`
12	`7911`	`if (string.Equals(currentMediaStream.Path, streamToFind.Path, StringComparison.Ordinal))`
	`7912`	`{`
12	`7913`	`index++;`
	`7914`	`}`
	`7915`	`}`
	`7916`
0	`7917`	`return -1;`
	`7918`	`}`
	`7919`
	`7920`	`public static bool IsCopyCodec(string codec)`
	`7921`	`{`
29	`7922`	`return string.Equals(codec, "copy", StringComparison.OrdinalIgnoreCase);`
	`7923`	`}`
	`7924`
	`7925`	`private static bool ShouldEncodeSubtitle(EncodingJobInfo state)`
	`7926`	`{`
10	`7927`	`return state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode`
10	`7928`	`\|\| (state.BaseRequest.AlwaysBurnInSubtitleWhenTranscoding && !IsCopyCodec(state.OutputVideoCodec));`
	`7929`	`}`
	`7930`
	`7931`	`private static bool NeedsExternalSubtitleMuxing(EncodingJobInfo state)`
	`7932`	`{`
4	`7933`	`return state.SubtitleStream is not null`
4	`7934`	`&& state.SubtitleStream.IsExternal`
4	`7935`	`&& (state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Embed`
4	`7936`	`\|\| (ShouldEncodeSubtitle(state) && !state.SubtitleStream.IsTextSubtitleStream));`
	`7937`	`}`
	`7938`
	`7939`	`public static string GetVideoSyncOption(string videoSync, Version encoderVersion)`
	`7940`	`{`
0	`7941`	`if (string.IsNullOrEmpty(videoSync))`
	`7942`	`{`
0	`7943`	`return string.Empty;`
	`7944`	`}`
	`7945`
0	`7946`	`if (encoderVersion >= new Version(5, 1))`
	`7947`	`{`
0	`7948`	`if (int.TryParse(videoSync, CultureInfo.InvariantCulture, out var vsync))`
	`7949`	`{`
0	`7950`	`return vsync switch`
0	`7951`	`{`
0	`7952`	`-1 => " -fps_mode auto",`
0	`7953`	`0 => " -fps_mode passthrough",`
0	`7954`	`1 => " -fps_mode cfr",`
0	`7955`	`2 => " -fps_mode vfr",`
0	`7956`	`_ => string.Empty`
0	`7957`	`};`
	`7958`	`}`
	`7959`
0	`7960`	`return string.Empty;`
	`7961`	`}`
	`7962`
	`7963`	`// -vsync is deprecated in FFmpeg 5.1 and will be removed in the future.`
0	`7964`	`return $" -vsync {videoSync}";`
	`7965`	`}`
	`7966`	`}`
	`7967`	`}`

Methods/Properties