< 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:	149
Uncovered lines:	3631
Coverable lines:	3780
Total lines:	7942
Line coverage:	3.9%

Branch coverage

Covered branches:	84
Total branches:	3767
Branch coverage:	2.2%

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%
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(...)	0%	6	2	0%
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(...)	0%	110	10	0%
GetSegmentFileExtension(...)	0%	6	2	0%
GetVideoBitrateParam(...)	0%	1806	42	0%
GetEncoderParam(...)	0%	8010	89	0%
NormalizeTranscodingLevel(...)	0%	506	22	0%
GetTextSubtitlesFilter(...)	0%	272	16	0%
GetFramerateParam(...)	0%	156	12	0%
GetHlsVideoKeyFrameArguments(...)	0%	1806	42	0%
GetVideoQualityParam(...)	0%	32580	180	0%
CanStreamCopyVideo(...)	0%	19740	140	0%
CanStreamCopyAudio(...)	0%	1190	34	0%
GetVideoBitrateParamValue(...)	0%	506	22	0%
GetMinBitrate(...)	0%	20	4	0%
GetVideoBitrateScaleFactor(...)	0%	72	8	0%
ScaleBitrate(...)	0%	110	10	0%
GetAudioBitrateParam(...)	100%	2	1	0%
GetAudioBitrateParam(...)	0%	2162	46	0%
GetAudioVbrModeParam(...)	0%	1190	34	0%
GetAudioFilterParam(...)	0%	702	26	0%
GetNumAudioChannelsParam(...)	0%	930	30	0%
EnforceResolutionLimit(...)	0%	20	4	0%
GetFastSeekCommandLineParameter(...)	4.54%	179	22	31.25%
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%	2550	50	0%
GetNvidiaVidFilterChain(...)	0%	110	10	0%
GetNvidiaVidFiltersPrefered(...)	0%	7832	88	0%
GetAmdVidFilterChain(...)	0%	210	14	0%
GetAmdDx11VidFiltersPrefered(...)	0%	7832	88	0%
GetIntelVidFilterChain(...)	0%	506	22	0%
GetIntelQsvDx11VidFiltersPrefered(...)	0%	20880	144	0%
GetIntelQsvVaapiVidFiltersPrefered(...)	0%	17556	132	0%
GetVaapiVidFilterChain(...)	0%	1190	34	0%
GetIntelVaapiFullVidFiltersPrefered(...)	0%	12656	112	0%
GetAmdVaapiFullVidFiltersPrefered(...)	0%	10100	100	0%
GetVaapiLimitedVidFiltersPrefered(...)	0%	8190	90	0%
GetAppleVidFilterChain(...)	0%	156	12	0%
GetAppleVidFiltersPreferred(...)	0%	5550	74	0%
GetRkmppVidFilterChain(...)	0%	272	16	0%
GetRkmppVidFiltersPrefered(...)	0%	16002	126	0%
GetVideoProcessingFilterParam(...)	0%	2756	52	0%
GetOverwriteColorPropertiesParam(...)	0%	20	4	0%
GetInputHdrParam(...)	0%	6	2	0%
GetOutputSdrParam(...)	0%	20	4	0%
GetVideoColorBitDepth(...)	0%	600	24	0%
GetHardwareVideoDecoder(...)	17.74%	1684	62	25%
GetHwDecoderName(...)	0%	1190	34	0%
GetHwaccelType(...)	0%	15006	122	0%
GetQsvHwVidDecoder(...)	0%	3192	56	0%
GetNvdecVidDecoder(...)	0%	2162	46	0%
GetAmfVidDecoder(...)	0%	1056	32	0%
GetVaapiVidDecoder(...)	0%	2756	52	0%
GetVideotoolboxVidDecoder(...)	0%	2352	48	0%
GetRkmppVidDecoder(...)	0%	2756	52	0%
GetNumberOfThreads(...)	0%	42	6	0%
TryStreamCopy(...)	0%	600	24	0%
GetFfmpegAnalyzeDurationArg(...)	50%	7	6	71.42%
GetFfmpegProbesizeArg()	50%	2	2	75%
GetInputModifier(...)	0%	3660	60	0%
AttachMediaSourceInfo(...)	0%	1806	42	0%
ShiftAudioCodecsIfNeeded(...)	0%	110	10	0%
ShiftVideoCodecsIfNeeded(...)	0%	110	10	0%
NormalizeSubtitleEmbed(...)	0%	42	6	0%
GetSubtitleEmbedArguments(...)	0%	72	8	0%
GetProgressiveVideoFullCommandLine(...)	0%	20	4	0%
GetOutputFFlags(...)	0%	20	4	0%
GetProgressiveVideoArguments(...)	0%	1482	38	0%
GetProgressiveVideoAudioArguments(...)	0%	600	24	0%
GetProgressiveAudioFullCommandLine(...)	0%	930	30	0%
FindIndex(...)	66.66%	6	6	88.88%
IsCopyCodec(...)	100%	1	1	100%
ShouldEncodeSubtitle(...)	75%	4	4	100%
NeedsExternalSubtitleMuxing(...)	62.5%	8	8	100%
GetVideoSyncOption(...)	0%	132	11	0%

File(s)

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

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

Methods/Properties