< 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:	3604
Coverable lines:	3787
Total lines:	7986
Line coverage:	4.8%

Branch coverage

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

Methods/Properties