< Summary - Jellyfin

Information
Class: MediaBrowser.Controller.MediaEncoding.EncodingHelper
Assembly: MediaBrowser.Controller
File(s): /srv/git/jellyfin/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
Line coverage
17%
Covered lines: 671
Uncovered lines: 3172
Coverable lines: 3843
Total lines: 8093
Line coverage: 17.4%
Branch coverage
13%
Covered branches: 515
Total branches: 3857
Branch coverage: 13.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 5/31/2026 - 12:15:44 AM Line coverage: 4.8% (183/3795) Branch coverage: 2.9% (112/3773) Total lines: 79716/11/2026 - 12:16:04 AM Line coverage: 4.8% (183/3779) Branch coverage: 2.9% (112/3741) Total lines: 79676/18/2026 - 12:16:24 AM Line coverage: 4.8% (183/3787) Branch coverage: 2.9% (112/3747) Total lines: 79866/22/2026 - 12:15:37 AM Line coverage: 8.8% (334/3788) Branch coverage: 4.4% (167/3747) Total lines: 79878/6/2026 - 12:17:15 AM Line coverage: 8.9% (340/3789) Branch coverage: 4.6% (173/3749) Total lines: 799310/29/2026 - 12:17:11 AM Line coverage: 15.5% (597/3843) Branch coverage: 12.2% (474/3857) Total lines: 809311/13/2026 - 12:19:51 AM Line coverage: 17.4% (671/3843) Branch coverage: 13.3% (515/3857) Total lines: 8093 5/31/2026 - 12:15:44 AM Line coverage: 4.8% (183/3795) Branch coverage: 2.9% (112/3773) Total lines: 79716/11/2026 - 12:16:04 AM Line coverage: 4.8% (183/3779) Branch coverage: 2.9% (112/3741) Total lines: 79676/18/2026 - 12:16:24 AM Line coverage: 4.8% (183/3787) Branch coverage: 2.9% (112/3747) Total lines: 79866/22/2026 - 12:15:37 AM Line coverage: 8.8% (334/3788) Branch coverage: 4.4% (167/3747) Total lines: 79878/6/2026 - 12:17:15 AM Line coverage: 8.9% (340/3789) Branch coverage: 4.6% (173/3749) Total lines: 799310/29/2026 - 12:17:11 AM Line coverage: 15.5% (597/3843) Branch coverage: 12.2% (474/3857) Total lines: 809311/13/2026 - 12:19:51 AM Line coverage: 17.4% (671/3843) Branch coverage: 13.3% (515/3857) Total lines: 8093

Coverage delta

Coverage delta 8 -8

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
.cctor()100%11100%
GetH264Encoder(...)100%210%
GetH265Encoder(...)100%210%
GetAv1Encoder(...)100%210%
GetH26xOrAv1Encoder(...)0%110100%
GetMjpegEncoder(...)0%210140%
IsVaapiSupported(...)0%2040%
IsVaapiFullSupported()0%272160%
IsRkmppFullSupported()0%4260%
IsOpenclFullSupported()0%4260%
IsCudaFullSupported()0%110100%
IsVulkanFullSupported()0%110100%
IsVideoToolboxFullSupported()0%7280%
IsSwTonemapAvailable(...)50%6680%
IsHwTonemapAvailable(...)0%420200%
IsVulkanHwTonemapAvailable(...)0%4260%
IsIntelVppTonemapAvailable(...)0%342180%
IsVideoToolboxTonemapAvailable(...)0%272160%
IsDeinterlaceAvailable(...)50%44100%
IsVideoStreamHevcRext(...)0%342180%
GetVideoEncoder(...)14.28%1091421.42%
GetUserAgentParam(...)50%2266.66%
GetRefererParam(...)50%2266.66%
GetInputFormat(...)0%1482380%
GetDecoderFromCodec(...)0%7280%
InferAudioCodec(...)80%100100100%
InferVideoCodec(...)0%156120%
GetVideoProfileScore(...)0%4260%
GetAudioEncoder(...)70%282072.72%
GetRkmppDeviceArgs(...)0%620%
GetVideoToolboxDeviceArgs(...)0%620%
GetCudaDeviceArgs(...)0%2040%
GetVulkanDeviceArgs(...)0%7280%
GetOpenclDeviceArgs(...)0%7280%
GetD3d11vaDeviceArgs(...)0%4260%
GetVaapiDeviceArgs(...)0%272160%
GetDrmDeviceArgs(...)0%2040%
GetQsvDeviceArgs(...)0%7280%
GetFilterHwDeviceArgs(...)0%620%
GetGraphicalSubCanvasSize(...)70%322068.75%
GetInputVideoHwaccelArgs(...)3.33%127531204.27%
GetInputArgument(...)55.55%1063662.22%
IsH264(...)50%44100%
IsH265(...)50%44100%
IsAv1(...)50%22100%
IsAAC(...)50%22100%
IsDoviWithHdr10Bl(...)58.33%1212100%
IsDovi(...)58.33%1212100%
IsHdr10Plus(...)0%7280%
ShouldRemoveDynamicHdrMetadata(...)61.53%282685.71%
CanEncoderRemoveDynamicHdrMetadata(...)61.11%221877.77%
IsDoviRemoved(...)83.33%66100%
IsHdr10PlusRemoved(...)0%4260%
GetBitStreamArgs(...)61.53%402672.41%
GetAudioBitStreamArguments(...)92.85%1414100%
GetCopiedAudioTrimBsf(...)92.85%1414100%
GetSegmentFileExtension(...)100%22100%
GetVideoBitrateParam(...)0%1482380%
GetEncoderParam(...)0%107121030%
NormalizeTranscodingLevel(...)0%506220%
GetTextSubtitlesFilter(...)0%272160%
GetFramerateParam(...)0%156120%
GetHlsVideoKeyFrameArguments(...)0%1806420%
GetVideoQualityParam(...)0%325801800%
CanStreamCopyVideo(...)52.14%137514060.21%
CanStreamCopyAudio(...)100%210%
CanStreamCopyAudio(...)0%2040%
GetAudioStreamCopyFailureReasons(...)0%1056320%
GetBitDepthCompensatedBitrate(...)0%210140%
GetVideoBitrateParamValue(...)0%506220%
GetMinBitrate(...)0%2040%
GetVideoBitrateScaleFactor(...)0%7280%
ScaleBitrate(...)0%110100%
GetAudioBitrateParam(...)100%210%
GetAudioBitrateParam(...)17.39%2844651.72%
GetAudioVbrModeParam(...)0%1190340%
GetAudioFilterParam(...)57.69%472668.42%
GetNumAudioChannelsParam(...)40%523070.83%
EnforceResolutionLimit(...)0%2040%
GetFastSeekCommandLineParameter(...)10%231050%
GetMapArgs(...)50%843666.66%
GetNegativeMapArgsByFilters(...)0%2040%
GetMediaStream(...)41.66%251255.55%
GetFixedOutputSize(...)0%272160%
IsScaleRatioSupported(...)0%506220%
GetHwScaleFilter(...)0%600240%
GetGraphicalSubPreProcessFilters(...)0%342180%
GetAlphaSrcFilter(...)0%4260%
GetSwScaleFilter(...)42.3%3862618.96%
GetFixedSwScaleFilter(...)0%132110%
GetSwDeinterlaceFilter(...)0%4260%
GetHwDeinterlaceFilter(...)0%1332360%
GetHwTonemapFilter(...)0%1332360%
GetLibplaceboFilter(...)0%1056320%
GetVideoTransposeDirection(...)0%156120%
GetSwVidFilterChain(...)50%644679.68%
GetNvidiaVidFilterChain(...)0%110100%
GetNvidiaVidFiltersPrefered(...)0%7140840%
GetAmdVidFilterChain(...)0%210140%
GetAmdDx11VidFiltersPrefered(...)0%7140840%
GetIntelVidFilterChain(...)0%506220%
GetIntelQsvDx11VidFiltersPrefered(...)0%197401400%
GetIntelQsvVaapiVidFiltersPrefered(...)0%165121280%
GetVaapiVidFilterChain(...)0%1190340%
GetIntelVaapiFullVidFiltersPrefered(...)0%117721080%
GetAmdVaapiFullVidFiltersPrefered(...)0%113421060%
GetVaapiLimitedVidFiltersPrefered(...)0%7482860%
GetAppleVidFilterChain(...)0%156120%
GetAppleVidFiltersPreferred(...)0%4970700%
GetRkmppVidFilterChain(...)0%272160%
GetRkmppVidFiltersPrefered(...)0%150061220%
GetVideoProcessingFilterParam(...)0%3192560%
GetOverwriteColorPropertiesParam(...)75%44100%
GetInputHdrParam(...)100%22100%
GetOutputSdrParam(...)50%5460%
GetVideoColorBitDepth(...)8.33%3072421.05%
GetHardwareVideoDecoder(...)22.58%14296229.16%
GetHwDecoderName(...)0%1190340%
GetHwaccelType(...)0%150061220%
GetQsvHwVidDecoder(...)0%3192560%
GetNvdecVidDecoder(...)0%2162460%
GetAmfVidDecoder(...)0%1056320%
GetVaapiVidDecoder(...)0%2756520%
GetVideotoolboxVidDecoder(...)0%2352480%
GetRkmppVidDecoder(...)0%2756520%
GetNumberOfThreads(...)50%7675%
TryStreamCopy(...)0%812280%
GetFfmpegAnalyzeDurationArg(...)50%7671.42%
GetFfmpegProbesizeArg()50%2275%
GetInputModifier(...)33.33%2856060.34%
AttachMediaSourceInfo(...)35.71%1524260.34%
ShiftAudioCodecsIfNeeded(...)10%771012.5%
ShiftVideoCodecsIfNeeded(...)0%110100%
NormalizeSubtitleEmbed(...)0%4260%
GetSubtitleEmbedArguments(...)0%7280%
GetProgressiveVideoFullCommandLine(...)0%2040%
GetOutputFFlags(...)0%2040%
GetProgressiveVideoArguments(...)0%1482380%
GetProgressiveVideoAudioArguments(...)46.42%442872.72%
GetProgressiveAudioFullCommandLine(...)55.88%373485.71%
FindIndex(...)66.66%6688.88%
GetSubtitleStreamIndexForFfmpeg(...)0%4260%
IsCopyCodec(...)100%11100%
ShouldEncodeSubtitle(...)75%44100%
NeedsExternalSubtitleMuxing(...)87.5%88100%
GetVideoSyncOption(...)0%132110%

File(s)

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

#LineLine coverage
 1#nullable disable
 2
 3#pragma warning disable CS1591
 4// We need lowercase normalized string for ffmpeg
 5#pragma warning disable CA1308
 6
 7using System;
 8using System.Collections.Generic;
 9using System.Globalization;
 10using System.IO;
 11using System.Linq;
 12using System.Runtime.InteropServices;
 13using System.Text;
 14using System.Text.RegularExpressions;
 15using System.Threading;
 16using Jellyfin.Data;
 17using Jellyfin.Data.Enums;
 18using Jellyfin.Database.Implementations.Enums;
 19using Jellyfin.Extensions;
 20using MediaBrowser.Common.Configuration;
 21using MediaBrowser.Controller.Extensions;
 22using MediaBrowser.Controller.IO;
 23using MediaBrowser.Model.Configuration;
 24using MediaBrowser.Model.Dlna;
 25using MediaBrowser.Model.Dto;
 26using MediaBrowser.Model.Entities;
 27using MediaBrowser.Model.MediaInfo;
 28using MediaBrowser.Model.Session;
 29using Microsoft.Extensions.Configuration;
 30using IConfigurationManager = MediaBrowser.Common.Configuration.IConfigurationManager;
 31
 32namespace MediaBrowser.Controller.MediaEncoding
 33{
 34    public partial class EncodingHelper
 35    {
 36        /// <summary>
 37        /// The codec validation regex string.
 38        /// This regular expression matches strings that consist of alphanumeric characters, hyphens,
 39        /// periods, underscores, commas, and vertical bars, with a length between 0 and 40 characters.
 40        /// This should matches all common valid codecs.
 41        /// </summary>
 42        public const string ContainerValidationRegexStr = @"^[a-zA-Z0-9\-\._,|]{0,40}$";
 43
 44        /// <summary>
 45        /// The level validation regex string.
 46        /// This regular expression matches strings representing a double.
 47        /// </summary>
 48        public const string LevelValidationRegexStr = @"-?[0-9]+(?:\.[0-9]+)?";
 49
 50        private const string _defaultMjpegEncoder = "mjpeg";
 51
 52        private const string QsvAlias = "qs";
 53        private const string VaapiAlias = "va";
 54        private const string D3d11vaAlias = "dx11";
 55        private const string VideotoolboxAlias = "vt";
 56        private const string RkmppAlias = "rk";
 57        private const string OpenclAlias = "ocl";
 58        private const string CudaAlias = "cu";
 59        private const string DrmAlias = "dr";
 60        private const string VulkanAlias = "vk";
 61        private readonly IApplicationPaths _appPaths;
 62        private readonly IMediaEncoder _mediaEncoder;
 63        private readonly ISubtitleEncoder _subtitleEncoder;
 64        private readonly IConfiguration _config;
 65        private readonly IConfigurationManager _configurationManager;
 66        private readonly IPathManager _pathManager;
 67
 68        // i915 hang was fixed by linux 6.2 (3f882f2)
 18169        private readonly Version _minKerneli915Hang = new Version(5, 18);
 18170        private readonly Version _maxKerneli915Hang = new Version(6, 1, 3);
 18171        private readonly Version _minFixedKernel60i915Hang = new Version(6, 0, 18);
 18172        private readonly Version _minKernelVersionAmdVkFmtModifier = new Version(5, 15);
 73
 18174        private readonly Version _minFFmpegImplicitHwaccel = new Version(6, 0);
 18175        private readonly Version _minFFmpegHwaUnsafeOutput = new Version(6, 0);
 18176        private readonly Version _minFFmpegOclCuTonemapMode = new Version(5, 1, 3);
 18177        private readonly Version _minFFmpegSvtAv1Params = new Version(5, 1);
 18178        private readonly Version _minFFmpegVaapiH26xEncA53CcSei = new Version(6, 0);
 18179        private readonly Version _minFFmpegReadrateOption = new Version(5, 0);
 18180        private readonly Version _minFFmpegWorkingVtHwSurface = new Version(7, 0, 1);
 18181        private readonly Version _minFFmpegDisplayRotationOption = new Version(6, 0);
 18182        private readonly Version _minFFmpegAdvancedTonemapMode = new Version(7, 0, 1);
 18183        private readonly Version _minFFmpegAlteredVaVkInterop = new Version(7, 0, 1);
 18184        private readonly Version _minFFmpegQsvVppTonemapOption = new Version(7, 0, 1);
 18185        private readonly Version _minFFmpegQsvVppOutRangeOption = new Version(7, 0, 1);
 18186        private readonly Version _minFFmpegVaapiDeviceVendorId = new Version(7, 0, 1);
 18187        private readonly Version _minFFmpegQsvVppScaleModeOption = new Version(6, 0);
 18188        private readonly Version _minFFmpegRkmppHevcDecDoviRpu = new Version(7, 1, 1);
 18189        private readonly Version _minFFmpegReadrateCatchupOption = new Version(8, 0);
 18190        private readonly Version _minFFmpegNoiseBsfDrop = new Version(5, 0);
 18191        private readonly Version _minFFmpegAmfAv1EncCAQ = new Version(7, 1);
 92
 293        private static readonly string[] _videoProfilesH264 =
 294        [
 295            "ConstrainedBaseline",
 296            "Baseline",
 297            "Extended",
 298            "Main",
 299            "High",
 2100            "ProgressiveHigh",
 2101            "ConstrainedHigh",
 2102            "High10"
 2103        ];
 104
 2105        private static readonly string[] _videoProfilesH265 =
 2106        [
 2107            "Main",
 2108            "Main10"
 2109        ];
 110
 2111        private static readonly string[] _videoProfilesAv1 =
 2112        [
 2113            "Main",
 2114            "High",
 2115            "Professional",
 2116        ];
 117
 2118        private static readonly HashSet<string> _mp4ContainerNames = new(StringComparer.OrdinalIgnoreCase)
 2119        {
 2120            "mp4",
 2121            "m4a",
 2122            "m4p",
 2123            "m4b",
 2124            "m4r",
 2125            "m4v",
 2126        };
 127
 2128        private static readonly TonemappingMode[] _legacyTonemapModes = [TonemappingMode.max, TonemappingMode.rgb];
 2129        private static readonly TonemappingMode[] _advancedTonemapModes = [TonemappingMode.lum, TonemappingMode.itp];
 130
 131        // Set max transcoding channels for encoders that can't handle more than a set amount of channels
 132        // AAC, FLAC, ALAC, libopus, libvorbis encoders all support at least 8 channels
 2133        private static readonly Dictionary<string, int> _audioTranscodeChannelLookup = new(StringComparer.OrdinalIgnoreC
 2134        {
 2135            { "libmp3lame", 2 },
 2136            { "libfdk_aac", 6 },
 2137            { "ac3", 6 },
 2138            { "eac3", 6 },
 2139            { "dca", 6 },
 2140            { "mlp", 6 },
 2141            { "truehd", 6 },
 2142        };
 143
 2144        private static readonly Dictionary<HardwareAccelerationType, string> _mjpegCodecMap = new()
 2145        {
 2146            { HardwareAccelerationType.vaapi, _defaultMjpegEncoder + "_vaapi" },
 2147            { HardwareAccelerationType.qsv, _defaultMjpegEncoder + "_qsv" },
 2148            { HardwareAccelerationType.videotoolbox, _defaultMjpegEncoder + "_videotoolbox" },
 2149            { HardwareAccelerationType.rkmpp, _defaultMjpegEncoder + "_rkmpp" }
 2150        };
 151
 2152        public static readonly string[] LosslessAudioCodecs =
 2153        [
 2154            "alac",
 2155            "ape",
 2156            "flac",
 2157            "mlp",
 2158            "truehd",
 2159            "wavpack"
 2160        ];
 161
 162        public EncodingHelper(
 163            IApplicationPaths appPaths,
 164            IMediaEncoder mediaEncoder,
 165            ISubtitleEncoder subtitleEncoder,
 166            IConfiguration config,
 167            IConfigurationManager configurationManager,
 168            IPathManager pathManager)
 169        {
 181170            _appPaths = appPaths;
 181171            _mediaEncoder = mediaEncoder;
 181172            _subtitleEncoder = subtitleEncoder;
 181173            _config = config;
 181174            _configurationManager = configurationManager;
 181175            _pathManager = pathManager;
 181176        }
 177
 178        private enum DynamicHdrMetadataRemovalPlan
 179        {
 180            None,
 181            RemoveDovi,
 182            RemoveHdr10Plus,
 183        }
 184
 185        /// <summary>
 186        /// The codec validation regex.
 187        /// This regular expression matches strings that consist of alphanumeric characters, hyphens,
 188        /// periods, underscores, commas, and vertical bars, with a length between 0 and 40 characters.
 189        /// This should matches all common valid codecs.
 190        /// </summary>
 191        [GeneratedRegex(ContainerValidationRegexStr)]
 192        public static partial Regex ContainerValidationRegex();
 193
 194        /// <summary>
 195        /// The level validation regex string.
 196        /// This regular expression matches strings representing a double.
 197        /// </summary>
 198        [GeneratedRegex(LevelValidationRegexStr)]
 199        public static partial Regex LevelValidationRegex();
 200
 201        [GeneratedRegex(@"\s+")]
 202        private static partial Regex WhiteSpaceRegex();
 203
 204        public string GetH264Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)
 0205            => GetH26xOrAv1Encoder("libx264", "h264", state, encodingOptions);
 206
 207        public string GetH265Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)
 0208            => GetH26xOrAv1Encoder("libx265", "hevc", state, encodingOptions);
 209
 210        public string GetAv1Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)
 0211            => GetH26xOrAv1Encoder("libsvtav1", "av1", state, encodingOptions);
 212
 213        private string GetH26xOrAv1Encoder(string defaultEncoder, string hwEncoder, EncodingJobInfo state, EncodingOptio
 214        {
 215            // Only use alternative encoders for video files.
 216            // When using concat with folder rips, if the mfx session fails to initialize, ffmpeg will be stuck retrying
 217            // Since transcoding of folder rips is experimental anyway, it's not worth adding additional variables such 
 0218            if (state.VideoType == VideoType.VideoFile)
 219            {
 0220                var hwType = encodingOptions.HardwareAccelerationType;
 221
 0222                var codecMap = new Dictionary<HardwareAccelerationType, string>()
 0223                {
 0224                    { HardwareAccelerationType.amf,                  hwEncoder + "_amf" },
 0225                    { HardwareAccelerationType.nvenc,                hwEncoder + "_nvenc" },
 0226                    { HardwareAccelerationType.qsv,                  hwEncoder + "_qsv" },
 0227                    { HardwareAccelerationType.vaapi,                hwEncoder + "_vaapi" },
 0228                    { HardwareAccelerationType.videotoolbox,         hwEncoder + "_videotoolbox" },
 0229                    { HardwareAccelerationType.v4l2m2m,              hwEncoder + "_v4l2m2m" },
 0230                    { HardwareAccelerationType.rkmpp,                hwEncoder + "_rkmpp" },
 0231                };
 232
 0233                if (hwType != HardwareAccelerationType.none
 0234                    && encodingOptions.EnableHardwareEncoding
 0235                    && codecMap.TryGetValue(hwType, out var preferredEncoder)
 0236                    && _mediaEncoder.SupportsEncoder(preferredEncoder))
 237                {
 0238                    return preferredEncoder;
 239                }
 240            }
 241
 0242            return defaultEncoder;
 243        }
 244
 245        private string GetMjpegEncoder(EncodingJobInfo state, EncodingOptions encodingOptions)
 246        {
 0247            if (state.VideoType == VideoType.VideoFile)
 248            {
 0249                var hwType = encodingOptions.HardwareAccelerationType;
 250
 251                // Only enable VA-API MJPEG encoder on Intel iHD driver.
 252                // Legacy platforms supported ONLY by i965 do not support MJPEG encoder.
 0253                if (hwType == HardwareAccelerationType.vaapi
 0254                    && !_mediaEncoder.IsVaapiDeviceInteliHD)
 255                {
 0256                    return _defaultMjpegEncoder;
 257                }
 258
 0259                if (hwType != HardwareAccelerationType.none
 0260                    && encodingOptions.EnableHardwareEncoding
 0261                    && _mjpegCodecMap.TryGetValue(hwType, out var preferredEncoder)
 0262                    && _mediaEncoder.SupportsEncoder(preferredEncoder))
 263                {
 0264                    return preferredEncoder;
 265                }
 266            }
 267
 0268            return _defaultMjpegEncoder;
 269        }
 270
 271        private bool IsVaapiSupported(EncodingJobInfo state)
 272        {
 273            // vaapi will throw an error with this input
 274            // [vaapi @ 0x7faed8000960] No VAAPI support for codec mpeg4 profile -99.
 0275            if (string.Equals(state.VideoStream?.Codec, "mpeg4", StringComparison.OrdinalIgnoreCase))
 276            {
 0277                return false;
 278            }
 279
 0280            return _mediaEncoder.SupportsHwaccel("vaapi");
 281        }
 282
 283        private bool IsVaapiFullSupported()
 284        {
 0285            return _mediaEncoder.SupportsHwaccel("drm")
 0286                   && _mediaEncoder.SupportsHwaccel("vaapi")
 0287                   && _mediaEncoder.SupportsFilter("scale_vaapi")
 0288                   && _mediaEncoder.SupportsFilter("deinterlace_vaapi")
 0289                   && _mediaEncoder.SupportsFilter("tonemap_vaapi")
 0290                   && _mediaEncoder.SupportsFilter("procamp_vaapi")
 0291                   && _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayVaapiFrameSync)
 0292                   && _mediaEncoder.SupportsFilter("transpose_vaapi")
 0293                   && _mediaEncoder.SupportsFilter("hwupload_vaapi");
 294        }
 295
 296        private bool IsRkmppFullSupported()
 297        {
 0298            return _mediaEncoder.SupportsHwaccel("rkmpp")
 0299                   && _mediaEncoder.SupportsFilter("scale_rkrga")
 0300                   && _mediaEncoder.SupportsFilter("vpp_rkrga")
 0301                   && _mediaEncoder.SupportsFilter("overlay_rkrga");
 302        }
 303
 304        private bool IsOpenclFullSupported()
 305        {
 0306            return _mediaEncoder.SupportsHwaccel("opencl")
 0307                   && _mediaEncoder.SupportsFilter("scale_opencl")
 0308                   && _mediaEncoder.SupportsFilterWithOption(FilterOptionType.TonemapOpenclBt2390)
 0309                   && _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayOpenclFrameSync);
 310
 311            // Let transpose_opencl optional for the time being.
 312        }
 313
 314        private bool IsCudaFullSupported()
 315        {
 0316            return _mediaEncoder.SupportsHwaccel("cuda")
 0317                   && _mediaEncoder.SupportsFilterWithOption(FilterOptionType.ScaleCudaFormat)
 0318                   && _mediaEncoder.SupportsFilter("yadif_cuda")
 0319                   && _mediaEncoder.SupportsFilterWithOption(FilterOptionType.TonemapCudaName)
 0320                   && _mediaEncoder.SupportsFilter("overlay_cuda")
 0321                   && _mediaEncoder.SupportsFilter("hwupload_cuda");
 322
 323            // Let transpose_cuda optional for the time being.
 324        }
 325
 326        private bool IsVulkanFullSupported()
 327        {
 0328            return _mediaEncoder.SupportsHwaccel("vulkan")
 0329                   && _mediaEncoder.SupportsFilter("libplacebo")
 0330                   && _mediaEncoder.SupportsFilter("scale_vulkan")
 0331                   && _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayVulkanFrameSync)
 0332                   && _mediaEncoder.SupportsFilter("transpose_vulkan")
 0333                   && _mediaEncoder.SupportsFilter("flip_vulkan");
 334        }
 335
 336        private bool IsVideoToolboxFullSupported()
 337        {
 0338            return _mediaEncoder.SupportsHwaccel("videotoolbox")
 0339                && _mediaEncoder.SupportsFilter("yadif_videotoolbox")
 0340                && _mediaEncoder.SupportsFilter("overlay_videotoolbox")
 0341                && _mediaEncoder.SupportsFilter("tonemap_videotoolbox")
 0342                && _mediaEncoder.SupportsFilter("scale_vt");
 343
 344            // Let transpose_vt optional for the time being.
 345        }
 346
 347        private bool IsSwTonemapAvailable(EncodingJobInfo state, EncodingOptions options)
 348        {
 6349            if (state.VideoStream is null
 6350                || GetVideoColorBitDepth(state) < 10
 6351                || !_mediaEncoder.SupportsFilter("tonemapx"))
 352            {
 0353                return false;
 354            }
 355
 6356            return state.VideoStream.VideoRange == VideoRange.HDR;
 357        }
 358
 359        private bool IsHwTonemapAvailable(EncodingJobInfo state, EncodingOptions options)
 360        {
 0361            if (state.VideoStream is null
 0362                || !options.EnableTonemapping
 0363                || GetVideoColorBitDepth(state) < 10)
 364            {
 0365                return false;
 366            }
 367
 0368            if (state.VideoStream.VideoRange == VideoRange.HDR
 0369                && state.VideoStream.VideoRangeType == VideoRangeType.DOVI)
 370            {
 371                // Only native SW decoder, HW accelerator and hevc_rkmpp decoder can parse dovi rpu.
 0372                var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 373
 0374                var isRkmppDecoder = vidDecoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);
 0375                if (isRkmppDecoder
 0376                    && _mediaEncoder.EncoderVersion >= _minFFmpegRkmppHevcDecDoviRpu
 0377                    && string.Equals(state.VideoStream?.Codec, "hevc", StringComparison.OrdinalIgnoreCase))
 378                {
 0379                    return true;
 380                }
 381
 0382                var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 0383                var isNvdecDecoder = vidDecoder.Contains("cuda", StringComparison.OrdinalIgnoreCase);
 0384                var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 0385                var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);
 0386                var isVideoToolBoxDecoder = vidDecoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);
 0387                return isSwDecoder || isNvdecDecoder || isVaapiDecoder || isD3d11vaDecoder || isVideoToolBoxDecoder;
 388            }
 389
 390            // GPU tonemapping supports all HDR RangeTypes
 0391            return state.VideoStream.VideoRange == VideoRange.HDR;
 392        }
 393
 394        private bool IsVulkanHwTonemapAvailable(EncodingJobInfo state, EncodingOptions options)
 395        {
 0396            if (state.VideoStream is null)
 397            {
 0398                return false;
 399            }
 400
 401            // libplacebo has partial Dolby Vision to SDR tonemapping support.
 0402            return options.EnableTonemapping
 0403                   && state.VideoStream.VideoRange == VideoRange.HDR
 0404                   && GetVideoColorBitDepth(state) == 10;
 405        }
 406
 407        private bool IsIntelVppTonemapAvailable(EncodingJobInfo state, EncodingOptions options)
 408        {
 0409            if (state.VideoStream is null
 0410                || !options.EnableVppTonemapping
 0411                || GetVideoColorBitDepth(state) < 10)
 412            {
 0413                return false;
 414            }
 415
 416            // prefer 'tonemap_vaapi' over 'vpp_qsv' on Linux for supporting Gen9/KBLx.
 417            // 'vpp_qsv' requires VPL, which is only supported on Gen12/TGLx and newer.
 0418            if (OperatingSystem.IsWindows()
 0419                && options.HardwareAccelerationType == HardwareAccelerationType.qsv
 0420                && _mediaEncoder.EncoderVersion < _minFFmpegQsvVppTonemapOption)
 421            {
 0422                return false;
 423            }
 424
 0425            return state.VideoStream.VideoRange == VideoRange.HDR
 0426                   && (state.VideoStream.VideoRangeType == VideoRangeType.HDR10
 0427                       || IsHdr10Plus(state.VideoStream)
 0428                       || IsDoviWithHdr10Bl(state.VideoStream));
 429        }
 430
 431        private bool IsVideoToolboxTonemapAvailable(EncodingJobInfo state, EncodingOptions options)
 432        {
 0433            if (state.VideoStream is null
 0434                || !options.EnableVideoToolboxTonemapping
 0435                || GetVideoColorBitDepth(state) < 10)
 436            {
 0437                return false;
 438            }
 439
 440            // Certain DV profile 5 video works in Safari with direct playing, but the VideoToolBox does not produce cor
 441            // All other HDR formats working.
 0442            return state.VideoStream.VideoRange == VideoRange.HDR
 0443                   && (state.VideoStream.VideoRangeType == VideoRangeType.HDR10
 0444                       || IsHdr10Plus(state.VideoStream)
 0445                       || IsDoviWithHdr10Bl(state.VideoStream)
 0446                       || state.VideoStream.VideoRangeType == VideoRangeType.HLG
 0447                       || state.VideoStream.VideoRangeType == VideoRangeType.DOVIInvalid);
 448        }
 449
 450        private static bool IsDeinterlaceAvailable(EncodingJobInfo state)
 451        {
 6452            var doDeintH264 = state.DeInterlace("h264", true) || state.DeInterlace("avc", true);
 6453            var doDeintHevc = state.DeInterlace("h265", true) || state.DeInterlace("hevc", true);
 6454            return doDeintH264 || doDeintHevc;
 455        }
 456
 457        private bool IsVideoStreamHevcRext(EncodingJobInfo state)
 458        {
 0459            var videoStream = state.VideoStream;
 0460            if (videoStream is null)
 461            {
 0462                return false;
 463            }
 464
 0465            return string.Equals(videoStream.Codec, "hevc", StringComparison.OrdinalIgnoreCase)
 0466                   && (string.Equals(videoStream.Profile, "Rext", StringComparison.OrdinalIgnoreCase)
 0467                       || string.Equals(videoStream.PixelFormat, "yuv420p12le", StringComparison.OrdinalIgnoreCase)
 0468                       || string.Equals(videoStream.PixelFormat, "yuv422p", StringComparison.OrdinalIgnoreCase)
 0469                       || string.Equals(videoStream.PixelFormat, "yuv422p10le", StringComparison.OrdinalIgnoreCase)
 0470                       || string.Equals(videoStream.PixelFormat, "yuv422p12le", StringComparison.OrdinalIgnoreCase)
 0471                       || string.Equals(videoStream.PixelFormat, "yuv444p", StringComparison.OrdinalIgnoreCase)
 0472                       || string.Equals(videoStream.PixelFormat, "yuv444p10le", StringComparison.OrdinalIgnoreCase)
 0473                       || string.Equals(videoStream.PixelFormat, "yuv444p12le", StringComparison.OrdinalIgnoreCase));
 474        }
 475
 476        /// <summary>
 477        /// Gets the name of the output video codec.
 478        /// </summary>
 479        /// <param name="state">Encoding state.</param>
 480        /// <param name="encodingOptions">Encoding options.</param>
 481        /// <returns>Encoder string.</returns>
 482        public string GetVideoEncoder(EncodingJobInfo state, EncodingOptions encodingOptions)
 483        {
 4484            var codec = state.OutputVideoCodec;
 485
 4486            if (!string.IsNullOrEmpty(codec))
 487            {
 0488                if (string.Equals(codec, "av1", StringComparison.OrdinalIgnoreCase))
 489                {
 0490                    return GetAv1Encoder(state, encodingOptions);
 491                }
 492
 0493                if (string.Equals(codec, "h265", StringComparison.OrdinalIgnoreCase)
 0494                    || string.Equals(codec, "hevc", StringComparison.OrdinalIgnoreCase))
 495                {
 0496                    return GetH265Encoder(state, encodingOptions);
 497                }
 498
 0499                if (string.Equals(codec, "h264", StringComparison.OrdinalIgnoreCase))
 500                {
 0501                    return GetH264Encoder(state, encodingOptions);
 502                }
 503
 0504                if (string.Equals(codec, "mjpeg", StringComparison.OrdinalIgnoreCase))
 505                {
 0506                    return GetMjpegEncoder(state, encodingOptions);
 507                }
 508
 0509                if (ContainerValidationRegex().IsMatch(codec))
 510                {
 0511                    return codec.ToLowerInvariant();
 512                }
 513            }
 514
 4515            return "copy";
 516        }
 517
 518        /// <summary>
 519        /// Gets the user agent param.
 520        /// </summary>
 521        /// <param name="state">The state.</param>
 522        /// <returns>System.String.</returns>
 523        public string GetUserAgentParam(EncodingJobInfo state)
 524        {
 14525            if (state.RemoteHttpHeaders.TryGetValue("User-Agent", out string useragent))
 526            {
 0527                return "-user_agent \"" + useragent + "\"";
 528            }
 529
 14530            return string.Empty;
 531        }
 532
 533        /// <summary>
 534        /// Gets the referer param.
 535        /// </summary>
 536        /// <param name="state">The state.</param>
 537        /// <returns>System.String.</returns>
 538        public string GetRefererParam(EncodingJobInfo state)
 539        {
 14540            if (state.RemoteHttpHeaders.TryGetValue("Referer", out string referer))
 541            {
 0542                return "-referer \"" + referer + "\"";
 543            }
 544
 14545            return string.Empty;
 546        }
 547
 548        public static string GetInputFormat(string container)
 549        {
 0550            if (string.IsNullOrEmpty(container) || !ContainerValidationRegex().IsMatch(container))
 551            {
 0552                return null;
 553            }
 554
 0555            container = container.Replace("mkv", "matroska", StringComparison.OrdinalIgnoreCase);
 556
 0557            if (string.Equals(container, "ts", StringComparison.OrdinalIgnoreCase))
 558            {
 0559                return "mpegts";
 560            }
 561
 562            // For these need to find out the ffmpeg names
 0563            if (string.Equals(container, "m2ts", StringComparison.OrdinalIgnoreCase))
 564            {
 0565                return null;
 566            }
 567
 0568            if (string.Equals(container, "wmv", StringComparison.OrdinalIgnoreCase))
 569            {
 0570                return null;
 571            }
 572
 0573            if (string.Equals(container, "mts", StringComparison.OrdinalIgnoreCase))
 574            {
 0575                return null;
 576            }
 577
 0578            if (string.Equals(container, "vob", StringComparison.OrdinalIgnoreCase))
 579            {
 0580                return null;
 581            }
 582
 0583            if (string.Equals(container, "mpg", StringComparison.OrdinalIgnoreCase))
 584            {
 0585                return null;
 586            }
 587
 0588            if (string.Equals(container, "mpeg", StringComparison.OrdinalIgnoreCase))
 589            {
 0590                return null;
 591            }
 592
 0593            if (string.Equals(container, "rec", StringComparison.OrdinalIgnoreCase))
 594            {
 0595                return null;
 596            }
 597
 0598            if (string.Equals(container, "dvr-ms", StringComparison.OrdinalIgnoreCase))
 599            {
 0600                return null;
 601            }
 602
 0603            if (string.Equals(container, "ogm", StringComparison.OrdinalIgnoreCase))
 604            {
 0605                return null;
 606            }
 607
 0608            if (string.Equals(container, "divx", StringComparison.OrdinalIgnoreCase))
 609            {
 0610                return null;
 611            }
 612
 0613            if (string.Equals(container, "tp", StringComparison.OrdinalIgnoreCase))
 614            {
 0615                return null;
 616            }
 617
 0618            if (string.Equals(container, "rmvb", StringComparison.OrdinalIgnoreCase))
 619            {
 0620                return null;
 621            }
 622
 0623            if (string.Equals(container, "rtp", StringComparison.OrdinalIgnoreCase))
 624            {
 0625                return null;
 626            }
 627
 628            // Seeing reported failures here, not sure yet if this is related to specifying input format
 0629            if (string.Equals(container, "m4v", StringComparison.OrdinalIgnoreCase))
 630            {
 0631                return null;
 632            }
 633
 634            // obviously don't do this for strm files
 0635            if (string.Equals(container, "strm", StringComparison.OrdinalIgnoreCase))
 636            {
 0637                return null;
 638            }
 639
 640            // ISO files don't have an ffmpeg format
 0641            if (string.Equals(container, "iso", StringComparison.OrdinalIgnoreCase))
 642            {
 0643                return null;
 644            }
 645
 0646            return container;
 647        }
 648
 649        /// <summary>
 650        /// Gets decoder from a codec.
 651        /// </summary>
 652        /// <param name="codec">Codec to use.</param>
 653        /// <returns>Decoder string.</returns>
 654        public string GetDecoderFromCodec(string codec)
 655        {
 656            // For these need to find out the ffmpeg names
 0657            if (string.Equals(codec, "mp2", StringComparison.OrdinalIgnoreCase))
 658            {
 0659                return null;
 660            }
 661
 0662            if (string.Equals(codec, "aac_latm", StringComparison.OrdinalIgnoreCase))
 663            {
 0664                return null;
 665            }
 666
 0667            if (string.Equals(codec, "eac3", StringComparison.OrdinalIgnoreCase))
 668            {
 0669                return null;
 670            }
 671
 0672            if (_mediaEncoder.SupportsDecoder(codec))
 673            {
 0674                return codec;
 675            }
 676
 0677            return null;
 678        }
 679
 680        /// <summary>
 681        /// Infers the audio codec based on the url.
 682        /// </summary>
 683        /// <param name="container">Container to use.</param>
 684        /// <returns>Codec string.</returns>
 685        public string InferAudioCodec(string container)
 686        {
 11687            if (string.IsNullOrWhiteSpace(container))
 688            {
 689                // this may not work, but if the client is that broken we cannot do anything better
 1690                return "aac";
 691            }
 692
 10693            var inferredCodec = container.ToLowerInvariant();
 694
 10695            return inferredCodec switch
 10696            {
 1697                "ogg" or "oga" or "ogv" or "webm" or "webma" => "opus",
 2698                "m4a" or "m4b" or "mp4" or "mov" or "mkv" or "mka" => "aac",
 1699                "ts" or "avi" or "flv" or "f4v" or "swf" => "mp3",
 10700                // Containers that share their name with the codec they carry.
 3701                "aac" or "ac3" or "alac" or "dts" or "eac3" or "flac" or "mp2" or "mp3" or "opus" or "truehd" or "vorbis
 10702                // Anything else - manifests such as m3u8/mpd in particular - names a container that
 10703                // is not an audio codec. Never hand that name to ffmpeg as an encoder.
 3704                _ => "aac"
 10705            };
 706        }
 707
 708        /// <summary>
 709        /// Infers the video codec.
 710        /// </summary>
 711        /// <param name="url">The URL.</param>
 712        /// <returns>System.Nullable{VideoCodecs}.</returns>
 713        public string InferVideoCodec(string url)
 714        {
 0715            var ext = Path.GetExtension(url.AsSpan());
 716
 0717            if (ext.Equals(".asf", StringComparison.OrdinalIgnoreCase))
 718            {
 0719                return "wmv";
 720            }
 721
 0722            if (ext.Equals(".webm", StringComparison.OrdinalIgnoreCase))
 723            {
 724                // TODO: this may not always mean VP8, as the codec ages
 0725                return "vp8";
 726            }
 727
 0728            if (ext.Equals(".ogg", StringComparison.OrdinalIgnoreCase) || ext.Equals(".ogv", StringComparison.OrdinalIgn
 729            {
 0730                return "theora";
 731            }
 732
 0733            if (ext.Equals(".m3u8", StringComparison.OrdinalIgnoreCase) || ext.Equals(".ts", StringComparison.OrdinalIgn
 734            {
 0735                return "h264";
 736            }
 737
 0738            return "copy";
 739        }
 740
 741        public int GetVideoProfileScore(string videoCodec, string videoProfile)
 742        {
 743            // strip spaces because they may be stripped out on the query string
 0744            string profile = videoProfile.Replace(" ", string.Empty, StringComparison.Ordinal);
 0745            if (string.Equals("h264", videoCodec, StringComparison.OrdinalIgnoreCase))
 746            {
 0747                return Array.FindIndex(_videoProfilesH264, x => string.Equals(x, profile, StringComparison.OrdinalIgnore
 748            }
 749
 0750            if (string.Equals("hevc", videoCodec, StringComparison.OrdinalIgnoreCase))
 751            {
 0752                return Array.FindIndex(_videoProfilesH265, x => string.Equals(x, profile, StringComparison.OrdinalIgnore
 753            }
 754
 0755            if (string.Equals("av1", videoCodec, StringComparison.OrdinalIgnoreCase))
 756            {
 0757                return Array.FindIndex(_videoProfilesAv1, x => string.Equals(x, profile, StringComparison.OrdinalIgnoreC
 758            }
 759
 0760            return -1;
 761        }
 762
 763        /// <summary>
 764        /// Gets the audio encoder.
 765        /// </summary>
 766        /// <param name="state">The state.</param>
 767        /// <returns>System.String.</returns>
 768        public string GetAudioEncoder(EncodingJobInfo state)
 769        {
 54770            var codec = state.OutputAudioCodec;
 771
 54772            if (!ContainerValidationRegex().IsMatch(codec))
 773            {
 0774                codec = "aac";
 775            }
 776
 54777            if (string.Equals(codec, "aac", StringComparison.OrdinalIgnoreCase))
 778            {
 779                // Use Apple's aac encoder if available as it provides best audio quality
 34780                if (_mediaEncoder.SupportsEncoder("aac_at"))
 781                {
 0782                    return "aac_at";
 783                }
 784
 785                // Use libfdk_aac for better audio quality if using custom build of FFmpeg which has fdk_aac support
 34786                if (_mediaEncoder.SupportsEncoder("libfdk_aac"))
 787                {
 0788                    return "libfdk_aac";
 789                }
 790
 34791                return "aac";
 792            }
 793
 20794            if (string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))
 795            {
 2796                return "libmp3lame";
 797            }
 798
 18799            if (string.Equals(codec, "vorbis", StringComparison.OrdinalIgnoreCase))
 800            {
 0801                return "libvorbis";
 802            }
 803
 18804            if (string.Equals(codec, "opus", StringComparison.OrdinalIgnoreCase))
 805            {
 6806                return "libopus";
 807            }
 808
 12809            if (string.Equals(codec, "flac", StringComparison.OrdinalIgnoreCase))
 810            {
 2811                return "flac";
 812            }
 813
 10814            if (string.Equals(codec, "dts", StringComparison.OrdinalIgnoreCase))
 815            {
 0816                return "dca";
 817            }
 818
 10819            if (string.Equals(codec, "alac", StringComparison.OrdinalIgnoreCase))
 820            {
 821                // The ffmpeg upstream breaks the AudioToolbox ALAC encoder in version 6.1 but fixes it in version 7.0.
 822                // Since ALAC is lossless in quality and the AudioToolbox encoder is not faster,
 823                // its only benefit is a smaller file size.
 824                // To prevent problems, use the ffmpeg native encoder instead.
 0825                return "alac";
 826            }
 827
 10828            return codec.ToLowerInvariant();
 829        }
 830
 831        private string GetRkmppDeviceArgs(string alias)
 832        {
 0833            alias ??= RkmppAlias;
 834
 835            // device selection in rk is not supported.
 0836            return " -init_hw_device rkmpp=" + alias;
 837        }
 838
 839        private string GetVideoToolboxDeviceArgs(string alias)
 840        {
 0841            alias ??= VideotoolboxAlias;
 842
 843            // device selection in vt is not supported.
 0844            return " -init_hw_device videotoolbox=" + alias;
 845        }
 846
 847        private string GetCudaDeviceArgs(int deviceIndex, string alias)
 848        {
 0849            alias ??= CudaAlias;
 0850            deviceIndex = deviceIndex >= 0
 0851                ? deviceIndex
 0852                : 0;
 853
 0854            return string.Format(
 0855                CultureInfo.InvariantCulture,
 0856                " -init_hw_device cuda={0}:{1}",
 0857                alias,
 0858                deviceIndex);
 859        }
 860
 861        private string GetVulkanDeviceArgs(int deviceIndex, string deviceName, string srcDeviceAlias, string alias)
 862        {
 0863            alias ??= VulkanAlias;
 0864            deviceIndex = deviceIndex >= 0
 0865                ? deviceIndex
 0866                : 0;
 0867            var vendorOpts = string.IsNullOrEmpty(deviceName)
 0868                ? ":" + deviceIndex
 0869                : ":" + "\"" + deviceName + "\"";
 0870            var options = string.IsNullOrEmpty(srcDeviceAlias)
 0871                ? vendorOpts
 0872                : "@" + srcDeviceAlias;
 873
 0874            return string.Format(
 0875                CultureInfo.InvariantCulture,
 0876                " -init_hw_device vulkan={0}{1}",
 0877                alias,
 0878                options);
 879        }
 880
 881        private string GetOpenclDeviceArgs(int deviceIndex, string deviceVendorName, string srcDeviceAlias, string alias
 882        {
 0883            alias ??= OpenclAlias;
 0884            deviceIndex = deviceIndex >= 0
 0885                ? deviceIndex
 0886                : 0;
 0887            var vendorOpts = string.IsNullOrEmpty(deviceVendorName)
 0888                ? ":0.0"
 0889                : ":." + deviceIndex + ",device_vendor=\"" + deviceVendorName + "\"";
 0890            var options = string.IsNullOrEmpty(srcDeviceAlias)
 0891                ? vendorOpts
 0892                : "@" + srcDeviceAlias;
 893
 0894            return string.Format(
 0895                CultureInfo.InvariantCulture,
 0896                " -init_hw_device opencl={0}{1}",
 0897                alias,
 0898                options);
 899        }
 900
 901        private string GetD3d11vaDeviceArgs(int deviceIndex, string deviceVendorId, string alias)
 902        {
 0903            alias ??= D3d11vaAlias;
 0904            deviceIndex = deviceIndex >= 0 ? deviceIndex : 0;
 0905            var options = string.IsNullOrEmpty(deviceVendorId)
 0906                ? deviceIndex.ToString(CultureInfo.InvariantCulture)
 0907                : ",vendor=" + deviceVendorId;
 908
 0909            return string.Format(
 0910                CultureInfo.InvariantCulture,
 0911                " -init_hw_device d3d11va={0}:{1}",
 0912                alias,
 0913                options);
 914        }
 915
 916        private string GetVaapiDeviceArgs(string renderNodePath, string driver, string kernelDriver, string vendorId, st
 917        {
 0918            alias ??= VaapiAlias;
 0919            var haveVendorId = !string.IsNullOrEmpty(vendorId)
 0920                && _mediaEncoder.EncoderVersion >= _minFFmpegVaapiDeviceVendorId;
 921
 922            // Priority: 'renderNodePath' > 'vendorId' > 'kernelDriver'
 0923            var driverOpts = File.Exists(renderNodePath)
 0924                ? renderNodePath
 0925                : (haveVendorId ? $",vendor_id={vendorId}" : (string.IsNullOrEmpty(kernelDriver) ? string.Empty : $",ker
 926
 927            // 'driver' behaves similarly to env LIBVA_DRIVER_NAME
 0928            driverOpts += string.IsNullOrEmpty(driver) ? string.Empty : ",driver=" + driver;
 929
 0930            var options = string.IsNullOrEmpty(srcDeviceAlias)
 0931                ? (string.IsNullOrEmpty(driverOpts) ? string.Empty : ":" + driverOpts)
 0932                : "@" + srcDeviceAlias;
 933
 0934            return string.Format(
 0935                CultureInfo.InvariantCulture,
 0936                " -init_hw_device vaapi={0}{1}",
 0937                alias,
 0938                options);
 939        }
 940
 941        private string GetDrmDeviceArgs(string renderNodePath, string alias)
 942        {
 0943            alias ??= DrmAlias;
 0944            renderNodePath = renderNodePath ?? "/dev/dri/renderD128";
 945
 0946            return string.Format(
 0947                CultureInfo.InvariantCulture,
 0948                " -init_hw_device drm={0}:{1}",
 0949                alias,
 0950                renderNodePath);
 951        }
 952
 953        private string GetQsvDeviceArgs(string renderNodePath, string alias)
 954        {
 0955            var arg = " -init_hw_device qsv=" + (alias ?? QsvAlias);
 0956            if (OperatingSystem.IsLinux())
 957            {
 958                // derive qsv from vaapi device
 0959                return GetVaapiDeviceArgs(renderNodePath, "iHD", "i915", "0x8086", null, VaapiAlias) + arg + "@" + Vaapi
 960            }
 961
 0962            if (OperatingSystem.IsWindows())
 963            {
 964                // on Windows, the deviceIndex is an int
 0965                if (int.TryParse(renderNodePath, NumberStyles.Integer, CultureInfo.InvariantCulture, out int deviceIndex
 966                {
 0967                    return GetD3d11vaDeviceArgs(deviceIndex, string.Empty, D3d11vaAlias) + arg + "@" + D3d11vaAlias;
 968                }
 969
 970                // derive qsv from d3d11va device
 0971                return GetD3d11vaDeviceArgs(0, "0x8086", D3d11vaAlias) + arg + "@" + D3d11vaAlias;
 972            }
 973
 0974            return null;
 975        }
 976
 977        private string GetFilterHwDeviceArgs(string alias)
 978        {
 0979            return string.IsNullOrEmpty(alias)
 0980                ? string.Empty
 0981                : " -filter_hw_device " + alias;
 982        }
 983
 984        public string GetGraphicalSubCanvasSize(EncodingJobInfo state)
 985        {
 986            // DVBSUB uses the fixed canvas size 720x576
 18987            if (state.SubtitleStream is not null
 18988                && ShouldEncodeSubtitle(state)
 18989                && !state.SubtitleStream.IsTextSubtitleStream
 18990                && !string.Equals(state.SubtitleStream.Codec, "DVBSUB", StringComparison.OrdinalIgnoreCase))
 991            {
 2992                var subtitleWidth = state.SubtitleStream?.Width;
 2993                var subtitleHeight = state.SubtitleStream?.Height;
 994
 2995                if (subtitleWidth.HasValue
 2996                    && subtitleHeight.HasValue
 2997                    && subtitleWidth.Value > 0
 2998                    && subtitleHeight.Value > 0)
 999                {
 01000                    return string.Format(
 01001                        CultureInfo.InvariantCulture,
 01002                        " -canvas_size {0}x{1}",
 01003                        subtitleWidth.Value,
 01004                        subtitleHeight.Value);
 1005                }
 1006            }
 1007
 181008            return string.Empty;
 1009        }
 1010
 1011        /// <summary>
 1012        /// Gets the input video hwaccel argument.
 1013        /// </summary>
 1014        /// <param name="state">Encoding state.</param>
 1015        /// <param name="options">Encoding options.</param>
 1016        /// <returns>Input video hwaccel arguments.</returns>
 1017        public string GetInputVideoHwaccelArgs(EncodingJobInfo state, EncodingOptions options)
 1018        {
 181019            if (!state.IsVideoRequest)
 1020            {
 141021                return string.Empty;
 1022            }
 1023
 41024            var vidEncoder = GetVideoEncoder(state, options) ?? string.Empty;
 41025            if (IsCopyCodec(vidEncoder))
 1026            {
 41027                return string.Empty;
 1028            }
 1029
 01030            var args = new StringBuilder();
 01031            var isWindows = OperatingSystem.IsWindows();
 01032            var isLinux = OperatingSystem.IsLinux();
 01033            var isMacOS = OperatingSystem.IsMacOS();
 01034            var optHwaccelType = options.HardwareAccelerationType;
 01035            var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 01036            var isHwTonemapAvailable = IsHwTonemapAvailable(state, options);
 1037
 01038            if (optHwaccelType == HardwareAccelerationType.vaapi)
 1039            {
 01040                if (!isLinux || !_mediaEncoder.SupportsHwaccel("vaapi"))
 1041                {
 01042                    return string.Empty;
 1043                }
 1044
 01045                var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 01046                var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 01047                if (!isVaapiDecoder && !isVaapiEncoder)
 1048                {
 01049                    return string.Empty;
 1050                }
 1051
 01052                if (_mediaEncoder.IsVaapiDeviceInteliHD)
 1053                {
 01054                    args.Append(GetVaapiDeviceArgs(options.VaapiDevice, "iHD", null, null, null, VaapiAlias));
 1055                }
 01056                else if (_mediaEncoder.IsVaapiDeviceInteli965)
 1057                {
 1058                    // Only override i965 since it has lower priority than iHD in libva lookup.
 01059                    Environment.SetEnvironmentVariable("LIBVA_DRIVER_NAME", "i965");
 01060                    Environment.SetEnvironmentVariable("LIBVA_DRIVER_NAME_JELLYFIN", "i965");
 01061                    args.Append(GetVaapiDeviceArgs(options.VaapiDevice, "i965", null, null, null, VaapiAlias));
 1062                }
 1063
 01064                var filterDevArgs = string.Empty;
 01065                var doOclTonemap = isHwTonemapAvailable && IsOpenclFullSupported();
 1066
 01067                if (_mediaEncoder.IsVaapiDeviceInteliHD || _mediaEncoder.IsVaapiDeviceInteli965)
 1068                {
 01069                    if (doOclTonemap && !isVaapiDecoder)
 1070                    {
 01071                        args.Append(GetOpenclDeviceArgs(0, null, VaapiAlias, OpenclAlias));
 01072                        filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);
 1073                    }
 1074                }
 01075                else if (_mediaEncoder.IsVaapiDeviceAmd)
 1076                {
 1077                    // Disable AMD EFC feature since it's still unstable in upstream Mesa.
 01078                    Environment.SetEnvironmentVariable("AMD_DEBUG", "noefc");
 1079
 01080                    if (IsVulkanFullSupported()
 01081                        && _mediaEncoder.IsVaapiDeviceSupportVulkanDrmInterop
 01082                        && Environment.OSVersion.Version >= _minKernelVersionAmdVkFmtModifier)
 1083                    {
 01084                        args.Append(GetDrmDeviceArgs(options.VaapiDevice, DrmAlias));
 01085                        args.Append(GetVaapiDeviceArgs(null, null, null, null, DrmAlias, VaapiAlias));
 01086                        args.Append(GetVulkanDeviceArgs(0, null, DrmAlias, VulkanAlias));
 1087
 1088                        // libplacebo wants an explicitly set vulkan filter device.
 01089                        filterDevArgs = GetFilterHwDeviceArgs(VulkanAlias);
 1090                    }
 1091                    else
 1092                    {
 01093                        args.Append(GetVaapiDeviceArgs(options.VaapiDevice, null, null, null, null, VaapiAlias));
 01094                        filterDevArgs = GetFilterHwDeviceArgs(VaapiAlias);
 1095
 01096                        if (doOclTonemap)
 1097                        {
 1098                            // ROCm/ROCr OpenCL runtime
 01099                            args.Append(GetOpenclDeviceArgs(0, "Advanced Micro Devices", null, OpenclAlias));
 01100                            filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);
 1101                        }
 1102                    }
 1103                }
 01104                else if (doOclTonemap)
 1105                {
 01106                    args.Append(GetOpenclDeviceArgs(0, null, null, OpenclAlias));
 01107                    filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);
 1108                }
 1109
 01110                args.Append(filterDevArgs);
 1111            }
 01112            else if (optHwaccelType == HardwareAccelerationType.qsv)
 1113            {
 01114                if ((!isLinux && !isWindows) || !_mediaEncoder.SupportsHwaccel("qsv"))
 1115                {
 01116                    return string.Empty;
 1117                }
 1118
 01119                var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);
 01120                var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 01121                var isQsvDecoder = vidDecoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);
 01122                var isQsvEncoder = vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);
 01123                var isHwDecoder = isQsvDecoder || isVaapiDecoder || isD3d11vaDecoder;
 01124                if (!isHwDecoder && !isQsvEncoder)
 1125                {
 01126                    return string.Empty;
 1127                }
 1128
 01129                args.Append(GetQsvDeviceArgs(options.QsvDevice, QsvAlias));
 01130                var filterDevArgs = GetFilterHwDeviceArgs(QsvAlias);
 1131                // child device used by qsv.
 01132                if (_mediaEncoder.SupportsHwaccel("vaapi") || _mediaEncoder.SupportsHwaccel("d3d11va"))
 1133                {
 01134                    if (isHwTonemapAvailable && IsOpenclFullSupported())
 1135                    {
 01136                        var srcAlias = isLinux ? VaapiAlias : D3d11vaAlias;
 01137                        args.Append(GetOpenclDeviceArgs(0, null, srcAlias, OpenclAlias));
 01138                        if (!isHwDecoder)
 1139                        {
 01140                            filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);
 1141                        }
 1142                    }
 1143                }
 1144
 01145                args.Append(filterDevArgs);
 1146            }
 01147            else if (optHwaccelType == HardwareAccelerationType.nvenc)
 1148            {
 01149                if ((!isLinux && !isWindows) || !IsCudaFullSupported())
 1150                {
 01151                    return string.Empty;
 1152                }
 1153
 01154                var isCuvidDecoder = vidDecoder.Contains("cuvid", StringComparison.OrdinalIgnoreCase);
 01155                var isNvdecDecoder = vidDecoder.Contains("cuda", StringComparison.OrdinalIgnoreCase);
 01156                var isNvencEncoder = vidEncoder.Contains("nvenc", StringComparison.OrdinalIgnoreCase);
 01157                var isHwDecoder = isNvdecDecoder || isCuvidDecoder;
 01158                if (!isHwDecoder && !isNvencEncoder)
 1159                {
 01160                    return string.Empty;
 1161                }
 1162
 01163                args.Append(GetCudaDeviceArgs(0, CudaAlias))
 01164                     .Append(GetFilterHwDeviceArgs(CudaAlias));
 1165            }
 01166            else if (optHwaccelType == HardwareAccelerationType.amf)
 1167            {
 01168                if (!isWindows || !_mediaEncoder.SupportsHwaccel("d3d11va"))
 1169                {
 01170                    return string.Empty;
 1171                }
 1172
 01173                var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);
 01174                var isAmfEncoder = vidEncoder.Contains("amf", StringComparison.OrdinalIgnoreCase);
 01175                if (!isD3d11vaDecoder && !isAmfEncoder)
 1176                {
 01177                    return string.Empty;
 1178                }
 1179
 1180                // no dxva video processor hw filter.
 01181                args.Append(GetD3d11vaDeviceArgs(0, "0x1002", D3d11vaAlias));
 01182                var filterDevArgs = string.Empty;
 01183                if (IsOpenclFullSupported())
 1184                {
 01185                    args.Append(GetOpenclDeviceArgs(0, null, D3d11vaAlias, OpenclAlias));
 01186                    filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);
 1187                }
 1188
 01189                args.Append(filterDevArgs);
 1190            }
 01191            else if (optHwaccelType == HardwareAccelerationType.videotoolbox)
 1192            {
 01193                if (!isMacOS || !_mediaEncoder.SupportsHwaccel("videotoolbox"))
 1194                {
 01195                    return string.Empty;
 1196                }
 1197
 01198                var isVideotoolboxDecoder = vidDecoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);
 01199                var isVideotoolboxEncoder = vidEncoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);
 01200                if (!isVideotoolboxDecoder && !isVideotoolboxEncoder)
 1201                {
 01202                    return string.Empty;
 1203                }
 1204
 1205                // videotoolbox hw filter does not require device selection
 01206                args.Append(GetVideoToolboxDeviceArgs(VideotoolboxAlias));
 1207            }
 01208            else if (optHwaccelType == HardwareAccelerationType.rkmpp)
 1209            {
 01210                if (!isLinux || !_mediaEncoder.SupportsHwaccel("rkmpp"))
 1211                {
 01212                    return string.Empty;
 1213                }
 1214
 01215                var isRkmppDecoder = vidDecoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);
 01216                var isRkmppEncoder = vidEncoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);
 01217                if (!isRkmppDecoder && !isRkmppEncoder)
 1218                {
 01219                    return string.Empty;
 1220                }
 1221
 01222                args.Append(GetRkmppDeviceArgs(RkmppAlias));
 1223
 01224                var filterDevArgs = string.Empty;
 01225                var doOclTonemap = isHwTonemapAvailable && IsOpenclFullSupported();
 1226
 01227                if (doOclTonemap && !isRkmppDecoder)
 1228                {
 01229                    args.Append(GetOpenclDeviceArgs(0, null, RkmppAlias, OpenclAlias));
 01230                    filterDevArgs = GetFilterHwDeviceArgs(OpenclAlias);
 1231                }
 1232
 01233                args.Append(filterDevArgs);
 1234            }
 1235
 01236            if (!string.IsNullOrEmpty(vidDecoder))
 1237            {
 01238                args.Append(vidDecoder);
 1239            }
 1240
 01241            return args.ToString().Trim();
 1242        }
 1243
 1244        /// <summary>
 1245        /// Gets the input argument.
 1246        /// </summary>
 1247        /// <param name="state">Encoding state.</param>
 1248        /// <param name="options">Encoding options.</param>
 1249        /// <param name="segmentContainer">Segment Container.</param>
 1250        /// <returns>Input arguments.</returns>
 1251        public string GetInputArgument(EncodingJobInfo state, EncodingOptions options, string segmentContainer)
 1252        {
 181253            var arg = new StringBuilder();
 181254            var inputVidHwaccelArgs = GetInputVideoHwaccelArgs(state, options);
 1255
 181256            if (!string.IsNullOrEmpty(inputVidHwaccelArgs))
 1257            {
 01258                arg.Append(inputVidHwaccelArgs);
 1259            }
 1260
 181261            var canvasArgs = GetGraphicalSubCanvasSize(state);
 181262            if (!string.IsNullOrEmpty(canvasArgs))
 1263            {
 01264                arg.Append(canvasArgs);
 1265            }
 1266
 181267            if (state.MediaSource.VideoType == VideoType.Dvd || state.MediaSource.VideoType == VideoType.BluRay)
 1268            {
 01269                var concatFilePath = Path.Join(_configurationManager.CommonApplicationPaths.CachePath, "concat", state.M
 01270                if (!File.Exists(concatFilePath))
 1271                {
 01272                    _mediaEncoder.GenerateConcatConfig(state.MediaSource, concatFilePath);
 1273                }
 1274
 01275                arg.Append(" -f concat -safe 0 -i \"")
 01276                    .Append(concatFilePath)
 01277                    .Append("\" ");
 1278            }
 1279            else
 1280            {
 181281                arg.Append(" -i ")
 181282                    .Append(_mediaEncoder.GetInputPathArgument(state));
 1283            }
 1284
 181285            if (NeedsExternalSubtitleMuxing(state))
 1286            {
 41287                var subtitlePath = state.SubtitleStream.Path;
 41288                var isGraphicalBurnIn = ShouldEncodeSubtitle(state) && !state.SubtitleStream.IsTextSubtitleStream;
 1289
 1290                // dvdsub/vobsub graphical subtitles use .sub+.idx pairs
 41291                var subtitleExtension = Path.GetExtension(subtitlePath.AsSpan());
 41292                if (subtitleExtension.Equals(".sub", StringComparison.OrdinalIgnoreCase))
 1293                {
 41294                    var idxFile = Path.ChangeExtension(subtitlePath, ".idx");
 41295                    if (File.Exists(idxFile))
 1296                    {
 21297                        subtitlePath = idxFile;
 1298                    }
 1299                }
 1300
 1301                // Use analyzeduration also for subtitle streams to improve resolution detection  with streams inside MK
 41302                var analyzeDurationArgument = GetFfmpegAnalyzeDurationArg(state);
 41303                if (!string.IsNullOrEmpty(analyzeDurationArgument))
 1304                {
 01305                    arg.Append(' ').Append(analyzeDurationArgument);
 1306                }
 1307
 1308                // Apply probesize, too, if configured
 41309                var ffmpegProbeSizeArgument = GetFfmpegProbesizeArg();
 41310                if (!string.IsNullOrEmpty(ffmpegProbeSizeArgument))
 1311                {
 01312                    arg.Append(' ').Append(ffmpegProbeSizeArgument);
 1313                }
 1314
 1315                // Also seek the external subtitles stream.
 41316                var seekSubParam = GetFastSeekCommandLineParameter(state, options, segmentContainer);
 41317                if (!string.IsNullOrEmpty(seekSubParam))
 1318                {
 01319                    arg.Append(' ').Append(seekSubParam);
 1320                }
 1321
 41322                if (isGraphicalBurnIn && !string.IsNullOrEmpty(canvasArgs))
 1323                {
 01324                    arg.Append(canvasArgs);
 1325                }
 1326
 41327                arg.Append(" -i file:\"").Append(subtitlePath.EscapeProcessArgument()).Append('\"');
 1328            }
 1329
 181330            if (state.AudioStream is not null && state.AudioStream.IsExternal)
 1331            {
 1332                // Also seek the external audio stream.
 01333                var seekAudioParam = GetFastSeekCommandLineParameter(state, options, segmentContainer);
 01334                if (!string.IsNullOrEmpty(seekAudioParam))
 1335                {
 01336                    arg.Append(' ').Append(seekAudioParam);
 1337                }
 1338
 01339                arg.Append(" -i \"").Append(state.AudioStream.Path.EscapeProcessArgument()).Append('"');
 1340            }
 1341
 1342            // Disable auto inserted SW scaler for HW decoders in case of changed resolution.
 181343            var isSwDecoder = string.IsNullOrEmpty(GetHardwareVideoDecoder(state, options));
 181344            if (!isSwDecoder)
 1345            {
 01346                arg.Append(" -noautoscale");
 1347            }
 1348
 181349            return arg.ToString();
 1350        }
 1351
 1352        /// <summary>
 1353        /// Determines whether the specified stream is H264.
 1354        /// </summary>
 1355        /// <param name="stream">The stream.</param>
 1356        /// <returns><c>true</c> if the specified stream is H264; otherwise, <c>false</c>.</returns>
 1357        public static bool IsH264(MediaStream stream)
 1358        {
 491359            var codec = stream.Codec ?? string.Empty;
 1360
 491361            return codec.Contains("264", StringComparison.OrdinalIgnoreCase)
 491362                    || codec.Contains("avc", StringComparison.OrdinalIgnoreCase);
 1363        }
 1364
 1365        public static bool IsH265(MediaStream stream)
 1366        {
 731367            var codec = stream.Codec ?? string.Empty;
 1368
 731369            return codec.Contains("265", StringComparison.OrdinalIgnoreCase)
 731370                || codec.Contains("hevc", StringComparison.OrdinalIgnoreCase);
 1371        }
 1372
 1373        public static bool IsAv1(MediaStream stream)
 1374        {
 481375            var codec = stream.Codec ?? string.Empty;
 1376
 481377            return codec.Contains("av1", StringComparison.OrdinalIgnoreCase);
 1378        }
 1379
 1380        public static bool IsAAC(MediaStream stream)
 1381        {
 591382            var codec = stream.Codec ?? string.Empty;
 1383
 591384            return codec.Contains("aac", StringComparison.OrdinalIgnoreCase);
 1385        }
 1386
 1387        public static bool IsDoviWithHdr10Bl(MediaStream stream)
 1388        {
 101389            var rangeType = stream?.VideoRangeType;
 1390
 101391            return rangeType is VideoRangeType.DOVIWithHDR10
 101392                or VideoRangeType.DOVIWithEL
 101393                or VideoRangeType.DOVIWithHDR10Plus
 101394                or VideoRangeType.DOVIWithELHDR10Plus
 101395                || (rangeType == VideoRangeType.DOVIInvalid
 101396                    && string.Equals(stream.ColorTransfer, "smpte2084", StringComparison.OrdinalIgnoreCase)); // invalid
 1397        }
 1398
 1399        public static bool IsDovi(MediaStream stream)
 1400        {
 51401            var rangeType = stream?.VideoRangeType;
 1402
 51403            return IsDoviWithHdr10Bl(stream)
 51404                   || (rangeType is VideoRangeType.DOVI
 51405                       or VideoRangeType.DOVIWithHLG
 51406                       or VideoRangeType.DOVIWithSDR
 51407                       or VideoRangeType.DOVIInvalid);
 1408        }
 1409
 1410        public static bool IsHdr10Plus(MediaStream stream)
 1411        {
 01412            var rangeType = stream?.VideoRangeType;
 1413
 01414            return rangeType is VideoRangeType.HDR10Plus
 01415                       or VideoRangeType.DOVIWithHDR10Plus
 01416                       or VideoRangeType.DOVIWithELHDR10Plus;
 1417        }
 1418
 1419        /// <summary>
 1420        /// Check if dynamic HDR metadata should be removed during stream copy.
 1421        /// Please note this check assumes the range check has already been done
 1422        /// and trivial fallbacks like HDR10+ to HDR10, DOVIWithHDR10 to HDR10 is already checked.
 1423        /// </summary>
 1424        private static DynamicHdrMetadataRemovalPlan ShouldRemoveDynamicHdrMetadata(EncodingJobInfo state)
 1425        {
 1701426            var videoStream = state.VideoStream;
 1701427            if (videoStream.VideoRange is not VideoRange.HDR
 1701428                && videoStream.VideoRangeType != VideoRangeType.DOVIInvalid)
 1429            {
 01430                return DynamicHdrMetadataRemovalPlan.None;
 1431            }
 1432
 1701433            var requestedRangeTypes = state.GetRequestedRangeTypes(state.VideoStream.Codec);
 1701434            if (requestedRangeTypes.Length == 0)
 1435            {
 241436                return DynamicHdrMetadataRemovalPlan.None;
 1437            }
 1438
 1461439            var requestHasHDR10 = requestedRangeTypes.Contains(VideoRangeType.HDR10.ToString(), StringComparison.Ordinal
 1461440            var requestHasDOVI = requestedRangeTypes.Contains(VideoRangeType.DOVI.ToString(), StringComparison.OrdinalIg
 1461441            var requestHasDOVIwithEL = requestedRangeTypes.Contains(VideoRangeType.DOVIWithEL.ToString(), StringComparis
 1461442            var requestHasDOVIwithELHDR10plus = requestedRangeTypes.Contains(VideoRangeType.DOVIWithELHDR10Plus.ToString
 1443
 1461444            var shouldRemoveHdr10Plus = false;
 1445            // Case 1: Client supports HDR10, does not support DOVI with EL but EL presets
 1461446            var shouldRemoveDovi = (!requestHasDOVIwithEL && requestHasHDR10) && videoStream.VideoRangeType == VideoRang
 1447
 1448            // Case 2: Client supports DOVI, does not support broken DOVI config
 1449            // Client does not report DOVI support should be allowed to copy bad data for remuxing as HDR10 players woul
 1461450            shouldRemoveDovi = shouldRemoveDovi || (requestHasDOVI && videoStream.VideoRangeType == VideoRangeType.DOVII
 1451
 1452            // Special case: we have a video with both EL and HDR10+
 1453            // If the client supports EL but not in the case of coexistence with HDR10+, remove HDR10+ for compatibility
 1454            // Otherwise, remove DOVI if the client is not a DOVI player
 1461455            if (videoStream.VideoRangeType == VideoRangeType.DOVIWithELHDR10Plus)
 1456            {
 01457                shouldRemoveHdr10Plus = requestHasDOVIwithEL && !requestHasDOVIwithELHDR10plus;
 01458                shouldRemoveDovi = shouldRemoveDovi || !shouldRemoveHdr10Plus;
 1459            }
 1460
 1461461            if (shouldRemoveDovi)
 1462            {
 641463                return DynamicHdrMetadataRemovalPlan.RemoveDovi;
 1464            }
 1465
 1466            // If the client is a Dolby Vision Player, remove the HDR10+ metadata to avoid playback issues
 821467            shouldRemoveHdr10Plus = shouldRemoveHdr10Plus || (requestHasDOVI && videoStream.VideoRangeType == VideoRange
 821468            return shouldRemoveHdr10Plus ? DynamicHdrMetadataRemovalPlan.RemoveHdr10Plus : DynamicHdrMetadataRemovalPlan
 1469        }
 1470
 1471        private bool CanEncoderRemoveDynamicHdrMetadata(DynamicHdrMetadataRemovalPlan plan, MediaStream videoStream)
 1472        {
 561473            return plan switch
 561474            {
 481475                DynamicHdrMetadataRemovalPlan.RemoveDovi => _mediaEncoder.SupportsBitStreamFilterWithOption(BitStreamFil
 481476                                                            || (IsH265(videoStream) && _mediaEncoder.SupportsBitStreamFi
 481477                                                            || (IsAv1(videoStream) && _mediaEncoder.SupportsBitStreamFil
 01478                DynamicHdrMetadataRemovalPlan.RemoveHdr10Plus => (IsH265(videoStream) && _mediaEncoder.SupportsBitStream
 01479                                                                 || (IsAv1(videoStream) && _mediaEncoder.SupportsBitStre
 81480                _ => true,
 561481            };
 1482        }
 1483
 1484        public bool IsDoviRemoved(EncodingJobInfo state)
 1485        {
 971486            return state?.VideoStream is not null && ShouldRemoveDynamicHdrMetadata(state) == DynamicHdrMetadataRemovalP
 971487                                              && CanEncoderRemoveDynamicHdrMetadata(DynamicHdrMetadataRemovalPlan.Remove
 1488        }
 1489
 1490        public bool IsHdr10PlusRemoved(EncodingJobInfo state)
 1491        {
 01492            return state?.VideoStream is not null && ShouldRemoveDynamicHdrMetadata(state) == DynamicHdrMetadataRemovalP
 01493                                                  && CanEncoderRemoveDynamicHdrMetadata(DynamicHdrMetadataRemovalPlan.Re
 1494        }
 1495
 1496        public string GetBitStreamArgs(EncodingJobInfo state, MediaStreamType streamType)
 1497        {
 491498            if (state is null)
 1499            {
 01500                return null;
 1501            }
 1502
 491503            var stream = streamType switch
 491504            {
 01505                MediaStreamType.Audio => state.AudioStream,
 491506                MediaStreamType.Video => state.VideoStream,
 01507                _ => state.VideoStream
 491508            };
 1509            // TODO This is auto inserted into the mpegts mux so it might not be needed.
 1510            // https://www.ffmpeg.org/ffmpeg-bitstream-filters.html#h264_005fmp4toannexb
 491511            if (IsH264(stream))
 1512            {
 01513                return "-bsf:v h264_mp4toannexb";
 1514            }
 1515
 491516            if (IsAAC(stream))
 1517            {
 1518                // Convert adts header(mpegts) to asc header(mp4).
 01519                return "-bsf:a aac_adtstoasc";
 1520            }
 1521
 491522            if (IsH265(stream))
 1523            {
 251524                var filter = "-bsf:v hevc_mp4toannexb";
 1525
 1526                // The following checks are not complete because the copy would be rejected
 1527                // if the encoder cannot remove required metadata.
 1528                // And if bsf is used, we must already be using copy codec.
 251529                switch (ShouldRemoveDynamicHdrMetadata(state))
 1530                {
 1531                    default:
 1532                    case DynamicHdrMetadataRemovalPlan.None:
 1533                        break;
 1534                    case DynamicHdrMetadataRemovalPlan.RemoveDovi:
 81535                        filter += _mediaEncoder.SupportsBitStreamFilterWithOption(BitStreamFilterOptionType.HevcMetadata
 81536                            ? ",hevc_metadata=remove_dovi=1"
 81537                            : ",dovi_rpu=strip=1";
 81538                        break;
 1539                    case DynamicHdrMetadataRemovalPlan.RemoveHdr10Plus:
 01540                        filter += ",hevc_metadata=remove_hdr10plus=1";
 1541                        break;
 1542                }
 1543
 251544                return filter;
 1545            }
 1546
 241547            if (IsAv1(stream))
 1548            {
 241549                switch (ShouldRemoveDynamicHdrMetadata(state))
 1550                {
 1551                    default:
 1552                    case DynamicHdrMetadataRemovalPlan.None:
 161553                        return null;
 1554                    case DynamicHdrMetadataRemovalPlan.RemoveDovi:
 81555                        return _mediaEncoder.SupportsBitStreamFilterWithOption(BitStreamFilterOptionType.Av1MetadataRemo
 81556                            ? "-bsf:v av1_metadata=remove_dovi=1"
 81557                            : "-bsf:v dovi_rpu=strip=1";
 1558                    case DynamicHdrMetadataRemovalPlan.RemoveHdr10Plus:
 01559                        return "-bsf:v av1_metadata=remove_hdr10plus=1";
 1560                }
 1561            }
 1562
 01563            return null;
 1564        }
 1565
 1566        public string GetAudioBitStreamArguments(EncodingJobInfo state, string segmentContainer, string mediaSourceConta
 1567        {
 121568            var filters = new List<string>();
 1569
 121570            var noiseFilter = GetCopiedAudioTrimBsf(state);
 121571            if (!string.IsNullOrEmpty(noiseFilter))
 1572            {
 61573                filters.Add(noiseFilter);
 1574            }
 1575
 121576            var segmentFormat = GetSegmentFileExtension(segmentContainer).TrimStart('.');
 1577
 1578            // Apply aac_adtstoasc bitstream filter when media source is in mpegts.
 121579            if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase)
 121580                && (string.Equals(mediaSourceContainer, "ts", StringComparison.OrdinalIgnoreCase)
 121581                    || string.Equals(mediaSourceContainer, "aac", StringComparison.OrdinalIgnoreCase)
 121582                    || string.Equals(mediaSourceContainer, "hls", StringComparison.OrdinalIgnoreCase))
 121583                && IsAAC(state.AudioStream))
 1584            {
 91585                filters.Add("aac_adtstoasc");
 1586            }
 1587
 121588            return filters.Count == 0
 121589                ? string.Empty
 121590                : " -bsf:a " + string.Join(',', filters);
 1591        }
 1592
 1593        // When video is transcoded, accurate_seek (the default) trims video to the
 1594        // exact seek point via decoder-side frame discard. But stream-copied audio
 1595        // bypasses the decoder, so it starts from the nearest keyframe — potentially
 1596        // seconds before the target. Use the noise bsf to drop copied audio packets
 1597        // before the seek target, achieving the same trim precision without
 1598        // re-encoding. The noise bsf's drop= parameter requires ffmpeg >= 5.0.
 1599        // Important: make sure not to use it with wtv because it breaks seeking
 1600        private string GetCopiedAudioTrimBsf(EncodingJobInfo state)
 1601        {
 121602            if (state.TranscodingType is not TranscodingJobType.Hls
 121603                || !state.IsVideoRequest
 121604                || IsCopyCodec(state.OutputVideoCodec)
 121605                || !IsCopyCodec(state.OutputAudioCodec)
 121606                || string.Equals(state.InputContainer, "wtv", StringComparison.OrdinalIgnoreCase)
 121607                || _mediaEncoder.EncoderVersion < _minFFmpegNoiseBsfDrop)
 1608            {
 51609                return null;
 1610            }
 1611
 71612            var startTicks = state.BaseRequest.StartTimeTicks ?? 0;
 71613            if (startTicks <= 0)
 1614            {
 11615                return null;
 1616            }
 1617
 61618            var seekSeconds = startTicks / (double)TimeSpan.TicksPerSecond;
 61619            return string.Format(
 61620                CultureInfo.InvariantCulture,
 61621                "noise=drop='lt(pts*tb\\,{0:F3})'",
 61622                seekSeconds);
 1623        }
 1624
 1625        public static string GetSegmentFileExtension(string segmentContainer)
 1626        {
 491627            if (!string.IsNullOrWhiteSpace(segmentContainer))
 1628            {
 471629                return "." + segmentContainer;
 1630            }
 1631
 21632            return ".ts";
 1633        }
 1634
 1635        private string GetVideoBitrateParam(EncodingJobInfo state, string videoCodec)
 1636        {
 01637            if (state.OutputVideoBitrate is null)
 1638            {
 01639                return string.Empty;
 1640            }
 1641
 01642            int bitrate = state.OutputVideoBitrate.Value;
 1643
 1644            // Bit rate under 1000k is not allowed in h264_qsv.
 01645            if (string.Equals(videoCodec, "h264_qsv", StringComparison.OrdinalIgnoreCase))
 1646            {
 01647                bitrate = Math.Max(bitrate, 1000);
 1648            }
 1649
 1650            // Currently use the same buffer size for all non-QSV encoders.
 1651            // Use long arithmetic to prevent int32 overflow for very high bitrate values.
 01652            int bufsize = (int)Math.Min((long)bitrate * 2, int.MaxValue);
 1653
 01654            if (string.Equals(videoCodec, "libsvtav1", StringComparison.OrdinalIgnoreCase))
 1655            {
 01656                return FormattableString.Invariant($" -b:v {bitrate} -bufsize {bufsize}");
 1657            }
 1658
 01659            if (string.Equals(videoCodec, "libx264", StringComparison.OrdinalIgnoreCase)
 01660                || string.Equals(videoCodec, "libx265", StringComparison.OrdinalIgnoreCase))
 1661            {
 01662                return FormattableString.Invariant($" -maxrate {bitrate} -bufsize {bufsize}");
 1663            }
 1664
 01665            if (string.Equals(videoCodec, "h264_qsv", StringComparison.OrdinalIgnoreCase)
 01666                || string.Equals(videoCodec, "hevc_qsv", StringComparison.OrdinalIgnoreCase)
 01667                || string.Equals(videoCodec, "av1_qsv", StringComparison.OrdinalIgnoreCase))
 1668            {
 1669                // TODO: probe QSV encoders' capabilities and enable more tuning options
 1670                // See also https://github.com/intel/media-delivery/blob/master/doc/quality.rst
 1671
 1672                // Some less powerful H.264 HW decoders require strict CPB size
 1673                // So bufsize optimizations should not be applied to them
 01674                int factor = 2;
 01675                var codec = state.ActualOutputVideoCodec;
 01676                var level = state.GetRequestedLevel(codec);
 01677                if (string.Equals(codec, "h264", StringComparison.OrdinalIgnoreCase)
 01678                    && double.TryParse(level, CultureInfo.InvariantCulture, out double requestedLevel)
 01679                    && requestedLevel < 51)
 1680                {
 01681                    factor = 1;
 1682                }
 1683
 1684                // Set (maxrate == bitrate + 1) to trigger VBR for better bitrate allocation
 1685                // Set (rc_init_occupancy == 2 * bitrate) and (bufsize == 4 * bitrate) to deal with drastic scene change
 1686                // Use long arithmetic and clamp to int.MaxValue to prevent int32 overflow
 1687                // (e.g. bitrate * 4 wraps to a negative value for bitrates above ~537 million)
 01688                int qsvMaxrate = (int)Math.Min((long)bitrate + 1, int.MaxValue);
 01689                int qsvInitOcc = (int)Math.Min((long)bitrate * 1 * factor, int.MaxValue);
 01690                int qsvBufsize = (int)Math.Min((long)bitrate * 2 * factor, int.MaxValue);
 1691
 01692                return string.Create(CultureInfo.InvariantCulture, $" -b:v {bitrate} -maxrate {qsvMaxrate} -rc_init_occu
 1693            }
 1694
 01695            if (string.Equals(videoCodec, "h264_amf", StringComparison.OrdinalIgnoreCase)
 01696                || string.Equals(videoCodec, "hevc_amf", StringComparison.OrdinalIgnoreCase))
 1697            {
 1698                // Override the too high default qmin 18 in transcoding preset in legacy h26x_amf
 01699                return FormattableString.Invariant($" -rc cbr -qmin 0 -qmax 32 -b:v {bitrate} -maxrate {bitrate} -bufsiz
 1700            }
 1701
 01702            if (string.Equals(videoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
 01703                || string.Equals(videoCodec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)
 01704                || string.Equals(videoCodec, "av1_vaapi", StringComparison.OrdinalIgnoreCase))
 1705            {
 1706                // VBR in i965 driver may result in pixelated output.
 01707                if (_mediaEncoder.IsVaapiDeviceInteli965)
 1708                {
 01709                    return FormattableString.Invariant($" -rc_mode CBR -b:v {bitrate} -maxrate {bitrate} -bufsize {bufsi
 1710                }
 1711
 01712                return FormattableString.Invariant($" -rc_mode VBR -b:v {bitrate} -maxrate {bitrate} -bufsize {bufsize}"
 1713            }
 1714
 01715            if (string.Equals(videoCodec, "h264_videotoolbox", StringComparison.OrdinalIgnoreCase)
 01716                || string.Equals(videoCodec, "hevc_videotoolbox", StringComparison.OrdinalIgnoreCase))
 1717            {
 1718                // The `maxrate` and `bufsize` options can potentially lead to performance regression
 1719                // and even encoder hangs, especially when the value is very high.
 01720                return FormattableString.Invariant($" -b:v {bitrate} -qmin -1 -qmax -1");
 1721            }
 1722
 01723            return FormattableString.Invariant($" -b:v {bitrate} -maxrate {bitrate} -bufsize {bufsize}");
 1724        }
 1725
 1726        private string GetEncoderParam(EncoderPreset? preset, EncoderPreset defaultPreset, EncodingOptions encodingOptio
 1727        {
 01728            var param = string.Empty;
 01729            var encoderPreset = preset ?? defaultPreset;
 01730            if (string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase) || isLibX265)
 1731            {
 01732                var presetString = encoderPreset switch
 01733                {
 01734                    EncoderPreset.auto => EncoderPreset.veryfast.ToString().ToLowerInvariant(),
 01735                    _ => encoderPreset.ToString().ToLowerInvariant()
 01736                };
 1737
 01738                param += " -preset " + presetString;
 1739
 01740                int encodeCrf = encodingOptions.H264Crf;
 01741                if (isLibX265)
 1742                {
 01743                    encodeCrf = encodingOptions.H265Crf;
 1744                }
 1745
 01746                if (encodeCrf >= 0 && encodeCrf <= 51)
 1747                {
 01748                    param += " -crf " + encodeCrf.ToString(CultureInfo.InvariantCulture);
 1749                }
 1750                else
 1751                {
 01752                    string defaultCrf = "23";
 01753                    if (isLibX265)
 1754                    {
 01755                        defaultCrf = "28";
 1756                    }
 1757
 01758                    param += " -crf " + defaultCrf;
 1759                }
 1760            }
 01761            else if (string.Equals(videoEncoder, "libsvtav1", StringComparison.OrdinalIgnoreCase))
 1762            {
 1763                // Default to use the recommended preset 10.
 1764                // Omit presets < 5, which are too slow for on the fly encoding.
 1765                // https://gitlab.com/AOMediaCodec/SVT-AV1/-/blob/master/Docs/Ffmpeg.md
 01766                param += encoderPreset switch
 01767                {
 01768                    EncoderPreset.veryslow => " -preset 5",
 01769                    EncoderPreset.slower => " -preset 6",
 01770                    EncoderPreset.slow => " -preset 7",
 01771                    EncoderPreset.medium => " -preset 8",
 01772                    EncoderPreset.fast => " -preset 9",
 01773                    EncoderPreset.faster => " -preset 10",
 01774                    EncoderPreset.veryfast => " -preset 11",
 01775                    EncoderPreset.superfast => " -preset 12",
 01776                    EncoderPreset.ultrafast => " -preset 13",
 01777                    _ => " -preset 10"
 01778                };
 1779            }
 01780            else if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
 01781                     || string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)
 01782                     || string.Equals(videoEncoder, "av1_vaapi", StringComparison.OrdinalIgnoreCase))
 1783            {
 1784                // -compression_level is not reliable on AMD.
 01785                if (_mediaEncoder.IsVaapiDeviceInteliHD)
 1786                {
 01787                    param += encoderPreset switch
 01788                    {
 01789                        EncoderPreset.veryslow => " -compression_level 1",
 01790                        EncoderPreset.slower => " -compression_level 2",
 01791                        EncoderPreset.slow => " -compression_level 3",
 01792                        EncoderPreset.medium => " -compression_level 4",
 01793                        EncoderPreset.fast => " -compression_level 5",
 01794                        EncoderPreset.faster => " -compression_level 6",
 01795                        EncoderPreset.veryfast => " -compression_level 7",
 01796                        EncoderPreset.superfast => " -compression_level 7",
 01797                        EncoderPreset.ultrafast => " -compression_level 7",
 01798                        _ => string.Empty
 01799                    };
 1800                }
 1801            }
 01802            else if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase) // h264 (h264_qsv)
 01803                     || string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase) // hevc (hevc_qsv)
 01804                     || string.Equals(videoEncoder, "av1_qsv", StringComparison.OrdinalIgnoreCase)) // av1 (av1_qsv)
 1805            {
 01806                EncoderPreset[] valid_presets = [EncoderPreset.veryslow, EncoderPreset.slower, EncoderPreset.slow, Encod
 1807
 01808                param += " -preset " + (valid_presets.Contains(encoderPreset) ? encoderPreset : EncoderPreset.veryfast).
 1809
 1810                // Enable MacroBlock level bitrate control for better subjective visual quality
 01811                if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)
 01812                    || string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase))
 1813                {
 01814                    param += " -mbbrc 1";
 1815                }
 1816            }
 01817            else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase) // h264 (h264_nvenc)
 01818                        || string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase) // hevc (hevc_n
 01819                        || string.Equals(videoEncoder, "av1_nvenc", StringComparison.OrdinalIgnoreCase) // av1 (av1_nven
 01820            )
 1821            {
 01822                param += encoderPreset switch
 01823                {
 01824                    EncoderPreset.veryslow => " -preset p7",
 01825                    EncoderPreset.slower => " -preset p6",
 01826                    EncoderPreset.slow => " -preset p5",
 01827                    EncoderPreset.medium => " -preset p4",
 01828                    EncoderPreset.fast => " -preset p3",
 01829                    EncoderPreset.faster => " -preset p2",
 01830                    _ => " -preset p1"
 01831                };
 1832
 1833                // Enable Spatial Adaptive Quantization for better subjective visual quality
 1834                // H.264 is skipped for now because Maxwell 1 does not support it
 01835                if (!string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase))
 1836                {
 01837                    param += " -spatial-aq 1 -aq-strength 15";
 1838                }
 1839            }
 01840            else if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase) // h264 (h264_amf)
 01841                        || string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase) // hevc (hevc_amf
 01842                        || string.Equals(videoEncoder, "av1_amf", StringComparison.OrdinalIgnoreCase) // av1 (av1_amf)
 01843            )
 1844            {
 01845                param += encoderPreset switch
 01846                {
 01847                    EncoderPreset.veryslow => " -quality quality",
 01848                    EncoderPreset.slower => " -quality quality",
 01849                    EncoderPreset.slow => " -quality quality",
 01850                    EncoderPreset.medium => " -quality balanced",
 01851                    _ => " -quality speed"
 01852                };
 1853
 1854                // Enable Variance Based/Context Adaptive Quantization for better subjective visual quality
 01855                if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)
 01856                    || string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase))
 1857                {
 01858                    param += " -vbaq 1";
 1859                }
 01860                else if (string.Equals(videoEncoder, "av1_amf", StringComparison.OrdinalIgnoreCase)
 01861                         && _mediaEncoder.EncoderVersion >= _minFFmpegAmfAv1EncCAQ)
 1862                {
 01863                    param += " -aq_mode caq";
 1864                }
 1865
 01866                if (string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase)
 01867                    || string.Equals(videoEncoder, "av1_amf", StringComparison.OrdinalIgnoreCase))
 1868                {
 01869                    param += " -header_insertion_mode gop";
 1870                }
 1871
 01872                if (string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase))
 1873                {
 01874                    param += " -gops_per_idr 1";
 1875                }
 1876            }
 01877            else if (string.Equals(videoEncoder, "h264_videotoolbox", StringComparison.OrdinalIgnoreCase) // h264 (h264_
 01878                        || string.Equals(videoEncoder, "hevc_videotoolbox", StringComparison.OrdinalIgnoreCase) // hevc 
 01879            )
 1880            {
 01881                param += encoderPreset switch
 01882                {
 01883                    EncoderPreset.veryslow => " -prio_speed 0",
 01884                    EncoderPreset.slower => " -prio_speed 0",
 01885                    EncoderPreset.slow => " -prio_speed 0",
 01886                    EncoderPreset.medium => " -prio_speed 0",
 01887                    _ => " -prio_speed 1"
 01888                };
 1889            }
 1890
 01891            return param;
 1892        }
 1893
 1894        public static string NormalizeTranscodingLevel(EncodingJobInfo state, string level)
 1895        {
 01896            if (!double.TryParse(level, CultureInfo.InvariantCulture, out double requestLevel))
 1897            {
 01898                return null;
 1899            }
 1900
 01901            if (string.Equals(state.ActualOutputVideoCodec, "av1", StringComparison.OrdinalIgnoreCase))
 1902            {
 1903                // Transcode to level 5.3 (15) and lower for maximum compatibility.
 1904                // https://en.wikipedia.org/wiki/AV1#Levels
 01905                if (requestLevel < 0 || requestLevel >= 15)
 1906                {
 01907                    return "15";
 1908                }
 1909            }
 01910            else if (string.Equals(state.ActualOutputVideoCodec, "hevc", StringComparison.OrdinalIgnoreCase)
 01911                     || string.Equals(state.ActualOutputVideoCodec, "h265", StringComparison.OrdinalIgnoreCase))
 1912            {
 1913                // Transcode to level 5.0 and lower for maximum compatibility.
 1914                // Level 5.0 is suitable for up to 4k 30fps hevc encoding, otherwise let the encoder to handle it.
 1915                // https://en.wikipedia.org/wiki/High_Efficiency_Video_Coding_tiers_and_levels
 1916                // MaxLumaSampleRate = 3840*2160*30 = 248832000 < 267386880.
 01917                if (requestLevel < 0 || requestLevel >= 150)
 1918                {
 01919                    return "150";
 1920                }
 1921            }
 01922            else if (string.Equals(state.ActualOutputVideoCodec, "h264", StringComparison.OrdinalIgnoreCase))
 1923            {
 1924                // Transcode to level 5.1 and lower for maximum compatibility.
 1925                // h264 4k 30fps requires at least level 5.1 otherwise it will break on safari fmp4.
 1926                // https://en.wikipedia.org/wiki/Advanced_Video_Coding#Levels
 01927                if (requestLevel < 0 || requestLevel >= 51)
 1928                {
 01929                    return "51";
 1930                }
 1931            }
 1932
 01933            return level;
 1934        }
 1935
 1936        /// <summary>
 1937        /// Gets the text subtitle param.
 1938        /// </summary>
 1939        /// <param name="state">The state.</param>
 1940        /// <param name="enableAlpha">Enable alpha processing.</param>
 1941        /// <param name="enableSub2video">Enable sub2video mode.</param>
 1942        /// <returns>System.String.</returns>
 1943        public string GetTextSubtitlesFilter(EncodingJobInfo state, bool enableAlpha, bool enableSub2video)
 1944        {
 01945            var seconds = Math.Round(TimeSpan.FromTicks(state.StartTimeTicks ?? 0).TotalSeconds);
 1946
 1947            // hls always copies timestamps
 01948            var setPtsParam = state.CopyTimestamps || state.TranscodingType != TranscodingJobType.Progressive
 01949                ? string.Empty
 01950                : string.Format(CultureInfo.InvariantCulture, ",setpts=PTS -{0}/TB", seconds);
 1951
 01952            var alphaParam = enableAlpha ? ":alpha=1" : string.Empty;
 01953            var sub2videoParam = enableSub2video ? ":sub2video=1" : string.Empty;
 1954
 01955            var fontPath = _pathManager.GetAttachmentFolderPath(state.MediaSource.Id);
 01956            var fontParam = fontPath is null
 01957                ? string.Empty
 01958                : string.Format(
 01959                    CultureInfo.InvariantCulture,
 01960                    ":fontsdir='{0}'",
 01961                    _mediaEncoder.EscapeSubtitleFilterPath(fontPath));
 1962
 01963            if (state.SubtitleStream.IsExternal)
 1964            {
 01965                var charsetParam = string.Empty;
 1966
 01967                if (!string.IsNullOrEmpty(state.SubtitleStream.Language))
 1968                {
 01969                    var charenc = _subtitleEncoder.GetSubtitleFileCharacterSet(
 01970                            state.SubtitleStream,
 01971                            state.SubtitleStream.Language,
 01972                            state.MediaSource,
 01973                            CancellationToken.None).GetAwaiter().GetResult();
 1974
 01975                    if (!string.IsNullOrEmpty(charenc))
 1976                    {
 01977                        charsetParam = ":charenc=" + charenc;
 1978                    }
 1979                }
 1980
 01981                return string.Format(
 01982                    CultureInfo.InvariantCulture,
 01983                    "subtitles=f='{0}'{1}{2}{3}{4}{5}",
 01984                    _mediaEncoder.EscapeSubtitleFilterPath(state.SubtitleStream.Path),
 01985                    charsetParam,
 01986                    alphaParam,
 01987                    sub2videoParam,
 01988                    fontParam,
 01989                    setPtsParam);
 1990            }
 1991
 01992            var subtitlePath = _subtitleEncoder.GetSubtitleFilePath(
 01993                    state.SubtitleStream,
 01994                    state.MediaSource,
 01995                    CancellationToken.None).GetAwaiter().GetResult();
 1996
 01997            return string.Format(
 01998                CultureInfo.InvariantCulture,
 01999                "subtitles=f='{0}'{1}{2}{3}{4}",
 02000                _mediaEncoder.EscapeSubtitleFilterPath(subtitlePath),
 02001                alphaParam,
 02002                sub2videoParam,
 02003                fontParam,
 02004                setPtsParam);
 2005        }
 2006
 2007        public double? GetFramerateParam(EncodingJobInfo state)
 2008        {
 02009            var request = state.BaseRequest;
 2010
 02011            if (request.Framerate.HasValue)
 2012            {
 02013                return request.Framerate.Value;
 2014            }
 2015
 02016            var maxrate = request.MaxFramerate;
 2017
 02018            if (maxrate.HasValue && state.VideoStream is not null)
 2019            {
 02020                var contentRate = state.VideoStream.ReferenceFrameRate;
 2021
 02022                if (contentRate.HasValue && contentRate.Value > maxrate.Value)
 2023                {
 02024                    return maxrate;
 2025                }
 2026            }
 2027
 02028            return null;
 2029        }
 2030
 2031        public string GetHlsVideoKeyFrameArguments(
 2032            EncodingJobInfo state,
 2033            string codec,
 2034            int segmentLength,
 2035            bool isEventPlaylist,
 2036            int? startNumber)
 2037        {
 02038            var args = string.Empty;
 02039            var gopArg = string.Empty;
 2040
 02041            var keyFrameArg = string.Format(
 02042                CultureInfo.InvariantCulture,
 02043                " -force_key_frames:0 \"expr:gte(t,n_forced*{0})\"",
 02044                segmentLength);
 2045
 02046            var framerate = state.VideoStream?.RealFrameRate;
 02047            if (framerate.HasValue)
 2048            {
 2049                // This is to make sure keyframe interval is limited to our segment,
 2050                // as forcing keyframes is not enough.
 2051                // Example: we encoded half of desired length, then codec detected
 2052                // scene cut and inserted a keyframe; next forced keyframe would
 2053                // be created outside of segment, which breaks seeking.
 02054                gopArg = string.Format(
 02055                    CultureInfo.InvariantCulture,
 02056                    " -g:v:0 {0} -keyint_min:v:0 {0}",
 02057                    Math.Ceiling(segmentLength * framerate.Value));
 2058            }
 2059
 2060            // Unable to force key frames using these encoders, set key frames by GOP.
 02061            if (string.Equals(codec, "h264_qsv", StringComparison.OrdinalIgnoreCase)
 02062                || string.Equals(codec, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
 02063                || string.Equals(codec, "h264_amf", StringComparison.OrdinalIgnoreCase)
 02064                || string.Equals(codec, "h264_rkmpp", StringComparison.OrdinalIgnoreCase)
 02065                || string.Equals(codec, "hevc_qsv", StringComparison.OrdinalIgnoreCase)
 02066                || string.Equals(codec, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
 02067                || string.Equals(codec, "hevc_rkmpp", StringComparison.OrdinalIgnoreCase)
 02068                || string.Equals(codec, "av1_qsv", StringComparison.OrdinalIgnoreCase)
 02069                || string.Equals(codec, "av1_nvenc", StringComparison.OrdinalIgnoreCase)
 02070                || string.Equals(codec, "av1_amf", StringComparison.OrdinalIgnoreCase)
 02071                || string.Equals(codec, "libsvtav1", StringComparison.OrdinalIgnoreCase))
 2072            {
 02073                args += gopArg;
 2074            }
 02075            else if (string.Equals(codec, "libx264", StringComparison.OrdinalIgnoreCase)
 02076                     || string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase)
 02077                     || string.Equals(codec, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
 02078                     || string.Equals(codec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)
 02079                     || string.Equals(codec, "av1_vaapi", StringComparison.OrdinalIgnoreCase))
 2080            {
 02081                args += keyFrameArg;
 2082
 2083                // prevent the libx264 from post processing to break the set keyframe.
 02084                if (string.Equals(codec, "libx264", StringComparison.OrdinalIgnoreCase))
 2085                {
 02086                    args += " -sc_threshold:v:0 0";
 2087                }
 2088            }
 2089            else
 2090            {
 02091                args += keyFrameArg + gopArg;
 2092            }
 2093
 2094            // The in-band Parameter Sets generated by the AMD HEVC VA-API encoder is inconsistent
 2095            // with the extradata generated by ffmpeg, causing decoding failures when using hvc1.
 02096            if (string.Equals(codec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)
 02097                && _mediaEncoder.IsVaapiDeviceAmd)
 2098            {
 2099                // Extracting the extradata from the in-band PS to bypass the issue.
 2100                // This can be removed once the issue is resolved in libva or Mesa.
 2101                // Transcoding is unavoidable here, so using BSF will not conflict with BSF in remuxing.
 02102                args += " -flags:v -global_header -bsf:v extract_extradata=remove=0";
 2103            }
 2104
 02105            return args;
 2106        }
 2107
 2108        /// <summary>
 2109        /// Gets the video bitrate to specify on the command line.
 2110        /// </summary>
 2111        /// <param name="state">Encoding state.</param>
 2112        /// <param name="videoEncoder">Video encoder to use.</param>
 2113        /// <param name="encodingOptions">Encoding options.</param>
 2114        /// <param name="defaultPreset">Default present to use for encoding.</param>
 2115        /// <returns>Video bitrate.</returns>
 2116        public string GetVideoQualityParam(EncodingJobInfo state, string videoEncoder, EncodingOptions encodingOptions, 
 2117        {
 02118            var param = string.Empty;
 2119
 2120            // Tutorials: Enable Intel GuC / HuC firmware loading for Low Power Encoding.
 2121            // https://01.org/group/43/downloads/firmware
 2122            // https://wiki.archlinux.org/title/intel_graphics#Enable_GuC_/_HuC_firmware_loading
 2123            // Intel Low Power Encoding can save unnecessary CPU-GPU synchronization,
 2124            // which will reduce overhead in performance intensive tasks such as 4k transcoding and tonemapping.
 02125            var intelLowPowerHwEncoding = false;
 2126
 2127            // Workaround for linux 5.18 to 6.1.3 i915 hang at cost of performance.
 2128            // https://github.com/intel/media-driver/issues/1456
 02129            var enableWaFori915Hang = false;
 2130
 02131            var hardwareAccelerationType = encodingOptions.HardwareAccelerationType;
 2132
 02133            if (hardwareAccelerationType == HardwareAccelerationType.vaapi)
 2134            {
 02135                var isIntelVaapiDriver = _mediaEncoder.IsVaapiDeviceInteliHD || _mediaEncoder.IsVaapiDeviceInteli965;
 2136
 02137                if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
 2138                {
 02139                    intelLowPowerHwEncoding = encodingOptions.EnableIntelLowPowerH264HwEncoder && isIntelVaapiDriver;
 2140                }
 02141                else if (string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase))
 2142                {
 02143                    intelLowPowerHwEncoding = encodingOptions.EnableIntelLowPowerHevcHwEncoder && isIntelVaapiDriver;
 2144                }
 2145            }
 02146            else if (hardwareAccelerationType == HardwareAccelerationType.qsv)
 2147            {
 02148                if (OperatingSystem.IsLinux())
 2149                {
 02150                    var ver = Environment.OSVersion.Version;
 02151                    var isFixedKernel60 = ver.Major == 6 && ver.Minor == 0 && ver >= _minFixedKernel60i915Hang;
 02152                    var isUnaffectedKernel = ver < _minKerneli915Hang || ver > _maxKerneli915Hang;
 2153
 02154                    if (!(isUnaffectedKernel || isFixedKernel60))
 2155                    {
 02156                        var vidDecoder = GetHardwareVideoDecoder(state, encodingOptions) ?? string.Empty;
 02157                        var isIntelDecoder = vidDecoder.Contains("qsv", StringComparison.OrdinalIgnoreCase)
 02158                                             || vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 02159                        var doOclTonemap = _mediaEncoder.SupportsHwaccel("qsv")
 02160                            && IsVaapiSupported(state)
 02161                            && IsOpenclFullSupported()
 02162                            && !IsIntelVppTonemapAvailable(state, encodingOptions)
 02163                            && IsHwTonemapAvailable(state, encodingOptions);
 2164
 02165                        enableWaFori915Hang = isIntelDecoder && doOclTonemap;
 2166                    }
 2167                }
 2168
 02169                if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase))
 2170                {
 02171                    intelLowPowerHwEncoding = encodingOptions.EnableIntelLowPowerH264HwEncoder;
 2172                }
 02173                else if (string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase))
 2174                {
 02175                    intelLowPowerHwEncoding = encodingOptions.EnableIntelLowPowerHevcHwEncoder;
 2176                }
 2177                else
 2178                {
 02179                    enableWaFori915Hang = false;
 2180                }
 2181            }
 2182
 02183            if (intelLowPowerHwEncoding)
 2184            {
 02185                param += " -low_power 1";
 2186            }
 2187
 02188            if (enableWaFori915Hang)
 2189            {
 02190                param += " -async_depth 1";
 2191            }
 2192
 02193            var isLibX265 = string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase);
 02194            var encodingPreset = encodingOptions.EncoderPreset;
 2195
 02196            param += GetEncoderParam(encodingPreset, defaultPreset, encodingOptions, videoEncoder, isLibX265);
 02197            param += GetVideoBitrateParam(state, videoEncoder);
 2198
 02199            var framerate = GetFramerateParam(state);
 02200            if (framerate.HasValue)
 2201            {
 02202                param += string.Format(CultureInfo.InvariantCulture, " -r {0}", framerate.Value.ToString(CultureInfo.Inv
 2203            }
 2204
 02205            var targetVideoCodec = state.ActualOutputVideoCodec;
 02206            if (string.Equals(targetVideoCodec, "h265", StringComparison.OrdinalIgnoreCase)
 02207                || string.Equals(targetVideoCodec, "hevc", StringComparison.OrdinalIgnoreCase))
 2208            {
 02209                targetVideoCodec = "hevc";
 2210            }
 2211
 02212            var profile = state.GetRequestedProfiles(targetVideoCodec).FirstOrDefault() ?? string.Empty;
 02213            profile = WhiteSpaceRegex().Replace(profile, string.Empty).ToLowerInvariant();
 2214
 02215            var videoProfiles = Array.Empty<string>();
 02216            if (string.Equals("h264", targetVideoCodec, StringComparison.OrdinalIgnoreCase))
 2217            {
 02218                videoProfiles = _videoProfilesH264;
 2219            }
 02220            else if (string.Equals("hevc", targetVideoCodec, StringComparison.OrdinalIgnoreCase))
 2221            {
 02222                videoProfiles = _videoProfilesH265;
 2223            }
 02224            else if (string.Equals("av1", targetVideoCodec, StringComparison.OrdinalIgnoreCase))
 2225            {
 02226                videoProfiles = _videoProfilesAv1;
 2227            }
 2228
 02229            if (!videoProfiles.Contains(profile, StringComparison.OrdinalIgnoreCase))
 2230            {
 02231                profile = string.Empty;
 2232            }
 2233
 2234            // We only transcode to HEVC 8-bit for now, force Main Profile.
 02235            if (profile.Contains("main10", StringComparison.OrdinalIgnoreCase)
 02236                || profile.Contains("mainstill", StringComparison.OrdinalIgnoreCase))
 2237            {
 02238                profile = "main";
 2239            }
 2240
 2241            // Extended Profile is not supported by any known h264 encoders, force Main Profile.
 02242            if (profile.Contains("extended", StringComparison.OrdinalIgnoreCase))
 2243            {
 02244                profile = "main";
 2245            }
 2246
 2247            // Only libx264 support encoding H264 High 10 Profile, otherwise force High Profile.
 02248            if (!string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase)
 02249                && profile.Contains("high10", StringComparison.OrdinalIgnoreCase))
 2250            {
 02251                profile = "high";
 2252            }
 2253
 2254            // We only need Main profile of AV1 encoders.
 02255            if (videoEncoder.Contains("av1", StringComparison.OrdinalIgnoreCase)
 02256                && (profile.Contains("high", StringComparison.OrdinalIgnoreCase)
 02257                    || profile.Contains("professional", StringComparison.OrdinalIgnoreCase)))
 2258            {
 02259                profile = "main";
 2260            }
 2261
 2262            // h264_vaapi does not support Baseline profile, force Constrained Baseline in this case,
 2263            // which is compatible (and ugly).
 02264            if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
 02265                && profile.Contains("baseline", StringComparison.OrdinalIgnoreCase))
 2266            {
 02267                profile = "constrained_baseline";
 2268            }
 2269
 2270            // libx264, h264_{qsv,nvenc,rkmpp} does not support Constrained Baseline profile, force Baseline in this cas
 02271            if ((string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase)
 02272                 || string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)
 02273                 || string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
 02274                 || string.Equals(videoEncoder, "h264_rkmpp", StringComparison.OrdinalIgnoreCase))
 02275                && profile.Contains("baseline", StringComparison.OrdinalIgnoreCase))
 2276            {
 02277                profile = "baseline";
 2278            }
 2279
 2280            // libx264, h264_{qsv,nvenc,vaapi,rkmpp} does not support Constrained High profile, force High in this case.
 02281            if ((string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase)
 02282                 || string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)
 02283                 || string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
 02284                 || string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
 02285                 || string.Equals(videoEncoder, "h264_rkmpp", StringComparison.OrdinalIgnoreCase))
 02286                && profile.Contains("high", StringComparison.OrdinalIgnoreCase))
 2287            {
 02288                profile = "high";
 2289            }
 2290
 02291            if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)
 02292                && profile.Contains("baseline", StringComparison.OrdinalIgnoreCase))
 2293            {
 02294                profile = "constrained_baseline";
 2295            }
 2296
 02297            if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)
 02298                && profile.Contains("constrainedhigh", StringComparison.OrdinalIgnoreCase))
 2299            {
 02300                profile = "constrained_high";
 2301            }
 2302
 02303            if (string.Equals(videoEncoder, "h264_videotoolbox", StringComparison.OrdinalIgnoreCase)
 02304                && profile.Contains("constrainedbaseline", StringComparison.OrdinalIgnoreCase))
 2305            {
 02306                profile = "constrained_baseline";
 2307            }
 2308
 02309            if (string.Equals(videoEncoder, "h264_videotoolbox", StringComparison.OrdinalIgnoreCase)
 02310                && profile.Contains("constrainedhigh", StringComparison.OrdinalIgnoreCase))
 2311            {
 02312                profile = "constrained_high";
 2313            }
 2314
 02315            if (!string.IsNullOrEmpty(profile))
 2316            {
 2317                // Currently there's no profile option in av1_nvenc encoder
 02318                if (!(string.Equals(videoEncoder, "av1_nvenc", StringComparison.OrdinalIgnoreCase)
 02319                      || string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase)))
 2320                {
 02321                    param += " -profile:v:0 " + profile;
 2322                }
 2323            }
 2324
 02325            var level = NormalizeTranscodingLevel(state, state.GetRequestedLevel(targetVideoCodec));
 2326
 02327            if (!string.IsNullOrEmpty(level))
 2328            {
 2329                // libx264, QSV, AMF can adjust the given level to match the output.
 02330                if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)
 02331                    || string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase))
 2332                {
 02333                    param += " -level " + level;
 2334                }
 02335                else if (string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase))
 2336                {
 2337                    // hevc_qsv use -level 51 instead of -level 153.
 02338                    if (double.TryParse(level, CultureInfo.InvariantCulture, out double hevcLevel))
 2339                    {
 02340                        param += " -level " + (hevcLevel / 3);
 2341                    }
 2342                }
 02343                else if (string.Equals(videoEncoder, "av1_qsv", StringComparison.OrdinalIgnoreCase)
 02344                         || string.Equals(videoEncoder, "libsvtav1", StringComparison.OrdinalIgnoreCase))
 2345                {
 2346                    // libsvtav1 and av1_qsv use -level 60 instead of -level 16
 2347                    // https://aomedia.org/av1/specification/annex-a/
 02348                    if (int.TryParse(level, NumberStyles.Any, CultureInfo.InvariantCulture, out int av1Level))
 2349                    {
 02350                        var x = 2 + (av1Level >> 2);
 02351                        var y = av1Level & 3;
 02352                        var res = (x * 10) + y;
 02353                        param += " -level " + res;
 2354                    }
 2355                }
 02356                else if (string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)
 02357                         || string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase)
 02358                         || string.Equals(videoEncoder, "av1_amf", StringComparison.OrdinalIgnoreCase))
 2359                {
 02360                    param += " -level " + level;
 2361                }
 02362                else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
 02363                         || string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
 02364                         || string.Equals(videoEncoder, "av1_nvenc", StringComparison.OrdinalIgnoreCase))
 2365                {
 2366                    // level option may cause NVENC to fail.
 2367                    // NVENC cannot adjust the given level, just throw an error.
 2368                }
 02369                else if (string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
 02370                         || string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)
 02371                         || string.Equals(videoEncoder, "av1_vaapi", StringComparison.OrdinalIgnoreCase))
 2372                {
 2373                    // level option may cause corrupted frames on AMD VAAPI.
 02374                    if (_mediaEncoder.IsVaapiDeviceInteliHD || _mediaEncoder.IsVaapiDeviceInteli965)
 2375                    {
 02376                        param += " -level " + level;
 2377                    }
 2378                }
 02379                else if (string.Equals(videoEncoder, "h264_rkmpp", StringComparison.OrdinalIgnoreCase)
 02380                         || string.Equals(videoEncoder, "hevc_rkmpp", StringComparison.OrdinalIgnoreCase))
 2381                {
 02382                    param += " -level " + level;
 2383                }
 02384                else if (!string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase))
 2385                {
 02386                    param += " -level " + level;
 2387                }
 2388            }
 2389
 02390            if (string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase))
 2391            {
 02392                param += " -x264opts:0 subme=0:me_range=16:rc_lookahead=10:me=hex:open_gop=0";
 2393            }
 2394
 02395            if (string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase))
 2396            {
 2397                // libx265 only accept level option in -x265-params.
 2398                // level option may cause libx265 to fail.
 2399                // libx265 cannot adjust the given level, just throw an error.
 02400                param += " -x265-params:0 no-scenecut=1:no-open-gop=1:no-info=1";
 2401
 02402                if (encodingOptions.EncoderPreset < EncoderPreset.ultrafast)
 2403                {
 2404                    // The following params are slower than the ultrafast preset, don't use when ultrafast is selected.
 02405                    param += ":subme=3:merange=25:rc-lookahead=10:me=star:ctu=32:max-tu-size=32:min-cu-size=16:rskip=2:r
 2406                }
 2407            }
 2408
 02409            if (string.Equals(videoEncoder, "libsvtav1", StringComparison.OrdinalIgnoreCase)
 02410                && _mediaEncoder.EncoderVersion >= _minFFmpegSvtAv1Params)
 2411            {
 02412                param += " -svtav1-params:0 rc=1:tune=0:film-grain=0:enable-overlays=1:enable-tf=0";
 2413            }
 2414
 2415            /* Access unit too large: 8192 < 20880 error */
 02416            if ((string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase) ||
 02417                 string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)) &&
 02418                 _mediaEncoder.EncoderVersion >= _minFFmpegVaapiH26xEncA53CcSei)
 2419            {
 02420                param += " -sei -a53_cc";
 2421            }
 2422
 02423            return param;
 2424        }
 2425
 2426        public bool CanStreamCopyVideo(EncodingJobInfo state, MediaStream videoStream)
 2427        {
 322428            var request = state.BaseRequest;
 2429
 322430            if (!request.AllowVideoStreamCopy)
 2431            {
 02432                return false;
 2433            }
 2434
 322435            if (videoStream.IsInterlaced
 322436                && state.DeInterlace(videoStream.Codec, false))
 2437            {
 02438                return false;
 2439            }
 2440
 322441            if (videoStream.IsAnamorphic ?? false)
 2442            {
 02443                if (request.RequireNonAnamorphic)
 2444                {
 02445                    return false;
 2446                }
 2447            }
 2448
 2449            // Can't stream copy if we're burning in subtitles
 322450            if (request.SubtitleStreamIndex.HasValue
 322451                && request.SubtitleStreamIndex.Value >= 0
 322452                && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
 2453            {
 02454                return false;
 2455            }
 2456
 322457            if (string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 322458                && videoStream.IsAVC.HasValue
 322459                && !videoStream.IsAVC.Value
 322460                && request.RequireAvc)
 2461            {
 02462                return false;
 2463            }
 2464
 2465            // Source and target codecs must match
 322466            if (string.IsNullOrEmpty(videoStream.Codec)
 322467                || (state.SupportedVideoCodecs.Length != 0
 322468                    && !state.SupportedVideoCodecs.Contains(videoStream.Codec, StringComparison.OrdinalIgnoreCase)))
 2469            {
 02470                return false;
 2471            }
 2472
 322473            var requestedProfiles = state.GetRequestedProfiles(videoStream.Codec);
 2474
 2475            // If client is requesting a specific video profile, it must match the source
 322476            if (requestedProfiles.Length > 0)
 2477            {
 02478                if (string.IsNullOrEmpty(videoStream.Profile))
 2479                {
 2480                    // return false;
 2481                }
 2482
 02483                var requestedProfile = requestedProfiles[0];
 2484                // strip spaces because they may be stripped out on the query string as well
 02485                if (!string.IsNullOrEmpty(videoStream.Profile)
 02486                    && !requestedProfiles.Contains(videoStream.Profile.Replace(" ", string.Empty, StringComparison.Ordin
 2487                {
 02488                    var currentScore = GetVideoProfileScore(videoStream.Codec, videoStream.Profile);
 02489                    var requestedScore = GetVideoProfileScore(videoStream.Codec, requestedProfile);
 2490
 02491                    if (currentScore == -1 || currentScore > requestedScore)
 2492                    {
 02493                        return false;
 2494                    }
 2495                }
 2496            }
 2497
 322498            var requestedRangeTypes = state.GetRequestedRangeTypes(videoStream.Codec);
 322499            if (requestedRangeTypes.Length > 0)
 2500            {
 242501                if (videoStream.VideoRangeType == VideoRangeType.Unknown)
 2502                {
 02503                    return false;
 2504                }
 2505
 2506                // DOVIWithHDR10 should be compatible with HDR10 supporting players. Same goes with HLG and of course SD
 242507                var requestHasHDR10 = requestedRangeTypes.Contains(VideoRangeType.HDR10.ToString(), StringComparison.Ord
 242508                var requestHasHLG = requestedRangeTypes.Contains(VideoRangeType.HLG.ToString(), StringComparison.Ordinal
 242509                var requestHasSDR = requestedRangeTypes.Contains(VideoRangeType.SDR.ToString(), StringComparison.Ordinal
 242510                var requestHasDOVI = requestedRangeTypes.Contains(VideoRangeType.DOVI.ToString(), StringComparison.Ordin
 2511
 2512                // If SDR is the only supported range, we should not copy any of the HDR streams.
 2513                // All the following copy check assumes at least one HDR format is supported.
 242514                if (requestedRangeTypes.Length == 1 && requestHasSDR && videoStream.VideoRangeType != VideoRangeType.SDR
 2515                {
 02516                    return false;
 2517                }
 2518
 2519                // If the client does not support DOVI and the video stream is DOVI without fallback, we should not copy
 242520                if (!requestHasDOVI && videoStream.VideoRangeType == VideoRangeType.DOVI)
 2521                {
 02522                    return false;
 2523                }
 2524
 242525                if (!requestedRangeTypes.Contains(videoStream.VideoRangeType.ToString(), StringComparison.OrdinalIgnoreC
 242526                     && !((requestHasHDR10 && videoStream.VideoRangeType == VideoRangeType.DOVIWithHDR10)
 242527                            || (requestHasHLG && videoStream.VideoRangeType == VideoRangeType.DOVIWithHLG)
 242528                            || (requestHasSDR && videoStream.VideoRangeType == VideoRangeType.DOVIWithSDR)
 242529                            || (requestHasHDR10 && videoStream.VideoRangeType == VideoRangeType.HDR10Plus)))
 2530                {
 2531                    // If the video stream is in HDR10+ or a static HDR format, don't allow copy if the client does not 
 242532                    if (videoStream.VideoRangeType is VideoRangeType.HDR10Plus or VideoRangeType.HDR10 or VideoRangeType
 2533                    {
 02534                        return false;
 2535                    }
 2536
 2537                    // Check complicated cases where we need to remove dynamic metadata
 2538                    // Conservatively refuse to copy if the encoder can't remove dynamic metadata,
 2539                    // but a removal is required for compatability reasons.
 242540                    var dynamicHdrMetadataRemovalPlan = ShouldRemoveDynamicHdrMetadata(state);
 242541                    if (!CanEncoderRemoveDynamicHdrMetadata(dynamicHdrMetadataRemovalPlan, videoStream))
 2542                    {
 82543                        return false;
 2544                    }
 2545                }
 2546            }
 2547
 242548            var requestedRotations = state.GetRequestedRotations(videoStream.Codec);
 242549            if (requestedRotations.Length > 0)
 2550            {
 02551                var rotation = state.VideoStream?.Rotation ?? 0;
 02552                if (rotation != 0
 02553                    && !requestedRotations.Contains(rotation.ToString(CultureInfo.InvariantCulture), StringComparison.Or
 2554                {
 02555                    return false;
 2556                }
 2557            }
 2558
 2559            // Video width must fall within requested value
 242560            if (request.MaxWidth.HasValue
 242561                && (!videoStream.Width.HasValue || videoStream.Width.Value > request.MaxWidth.Value))
 2562            {
 02563                return false;
 2564            }
 2565
 2566            // Video height must fall within requested value
 242567            if (request.MaxHeight.HasValue
 242568                && (!videoStream.Height.HasValue || videoStream.Height.Value > request.MaxHeight.Value))
 2569            {
 02570                return false;
 2571            }
 2572
 2573            // Video framerate must fall within requested value
 242574            var requestedFramerate = request.MaxFramerate ?? request.Framerate;
 242575            if (requestedFramerate.HasValue)
 2576            {
 02577                var videoFrameRate = videoStream.ReferenceFrameRate;
 2578
 2579                // Add a little tolerance to the framerate check because some videos might record a framerate
 2580                // that is slightly greater than the intended framerate, but the device can still play it correctly.
 2581                // 0.05 fps tolerance should be safe enough.
 02582                if (!videoFrameRate.HasValue || videoFrameRate.Value > requestedFramerate.Value + 0.05f)
 2583                {
 02584                    return false;
 2585                }
 2586            }
 2587
 2588            // Video bitrate must fall within requested value
 242589            if (request.VideoBitRate.HasValue
 242590                && (!videoStream.BitRate.HasValue || videoStream.BitRate.Value > request.VideoBitRate.Value))
 2591            {
 2592                // For LiveTV that has no bitrate, let's try copy if other conditions are met
 02593                if (string.IsNullOrWhiteSpace(request.LiveStreamId) || videoStream.BitRate.HasValue)
 2594                {
 02595                    return false;
 2596                }
 2597            }
 2598
 242599            var maxBitDepth = state.GetRequestedVideoBitDepth(videoStream.Codec);
 242600            if (maxBitDepth.HasValue)
 2601            {
 02602                if (videoStream.BitDepth.HasValue && videoStream.BitDepth.Value > maxBitDepth.Value)
 2603                {
 02604                    return false;
 2605                }
 2606            }
 2607
 242608            var maxRefFrames = state.GetRequestedMaxRefFrames(videoStream.Codec);
 242609            if (maxRefFrames.HasValue
 242610                && videoStream.RefFrames.HasValue && videoStream.RefFrames.Value > maxRefFrames.Value)
 2611            {
 02612                return false;
 2613            }
 2614
 2615            // If a specific level was requested, the source must match or be less than
 242616            var level = state.GetRequestedLevel(videoStream.Codec);
 242617            if (double.TryParse(level, CultureInfo.InvariantCulture, out var requestLevel))
 2618            {
 02619                if (!videoStream.Level.HasValue)
 2620                {
 2621                    // return false;
 2622                }
 2623
 02624                if (videoStream.Level.HasValue && videoStream.Level.Value > requestLevel)
 2625                {
 02626                    return false;
 2627                }
 2628            }
 2629
 242630            if (string.Equals(state.InputContainer, "avi", StringComparison.OrdinalIgnoreCase)
 242631                && string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase)
 242632                && !(videoStream.IsAVC ?? false))
 2633            {
 2634                // see Coach S01E01 - Kelly and the Professor(0).avi
 02635                return false;
 2636            }
 2637
 242638            return true;
 2639        }
 2640
 2641        public bool CanStreamCopyAudio(EncodingJobInfo state, MediaStream audioStream, IEnumerable<string> supportedAudi
 02642            => CanStreamCopyAudio(state, audioStream, supportedAudioCodecs, out _);
 2643
 2644        /// <summary>
 2645        /// Determines whether the given audio stream can be stream-copied and, regardless of the outcome,
 2646        /// reports the codec/parameter incompatibilities that would force a re-encode via <paramref name="failureReason
 2647        /// </summary>
 2648        /// <param name="state">The encoding job state.</param>
 2649        /// <param name="audioStream">The source audio stream.</param>
 2650        /// <param name="supportedAudioCodecs">The audio codecs the target supports.</param>
 2651        /// <param name="failureReasons">The codec/parameter incompatibilities preventing a copy, or <c>0</c> if the str
 2652        /// <returns><c>true</c> if the audio stream can be stream-copied; otherwise, <c>false</c>.</returns>
 2653        public bool CanStreamCopyAudio(EncodingJobInfo state, MediaStream audioStream, IEnumerable<string> supportedAudi
 2654        {
 02655            var request = state.BaseRequest;
 2656
 2657            // Policy-independent compatibility check, so the reasons are reported even when a policy gate is what ultim
 02658            failureReasons = GetAudioStreamCopyFailureReasons(state, audioStream, supportedAudioCodecs);
 2659
 02660            return request.AllowAudioStreamCopy
 02661                && request.EnableAutoStreamCopy
 02662                && failureReasons == 0;
 2663        }
 2664
 2665        private static TranscodeReason GetAudioStreamCopyFailureReasons(EncodingJobInfo state, MediaStream audioStream, 
 2666        {
 02667            var request = state.BaseRequest;
 02668            TranscodeReason reasons = 0;
 2669
 02670            var maxBitDepth = state.GetRequestedAudioBitDepth(audioStream.Codec);
 02671            if (maxBitDepth.HasValue
 02672                && audioStream.BitDepth.HasValue
 02673                && audioStream.BitDepth.Value > maxBitDepth.Value)
 2674            {
 02675                reasons |= TranscodeReason.AudioBitDepthNotSupported;
 2676            }
 2677
 2678            // Source and target codecs must match
 02679            if (string.IsNullOrEmpty(audioStream.Codec)
 02680                || !supportedAudioCodecs.Contains(audioStream.Codec, StringComparison.OrdinalIgnoreCase))
 2681            {
 02682                reasons |= TranscodeReason.AudioCodecNotSupported;
 2683            }
 2684
 2685            // Channels must fall within requested value
 02686            var channels = state.GetRequestedAudioChannels(audioStream.Codec);
 02687            if (channels.HasValue
 02688                && (!audioStream.Channels.HasValue
 02689                    || audioStream.Channels.Value <= 0
 02690                    || audioStream.Channels.Value > channels.Value))
 2691            {
 02692                reasons |= TranscodeReason.AudioChannelsNotSupported;
 2693            }
 2694
 2695            // Sample rate must fall within requested value
 02696            if (request.AudioSampleRate.HasValue
 02697                && (!audioStream.SampleRate.HasValue
 02698                    || audioStream.SampleRate.Value <= 0
 02699                    || audioStream.SampleRate.Value > request.AudioSampleRate.Value))
 2700            {
 02701                reasons |= TranscodeReason.AudioSampleRateNotSupported;
 2702            }
 2703
 2704            // Audio bitrate must fall within requested value
 02705            if (request.AudioBitRate.HasValue
 02706                && audioStream.BitRate.HasValue
 02707                && audioStream.BitRate.Value > request.AudioBitRate.Value)
 2708            {
 02709                reasons |= TranscodeReason.AudioBitrateNotSupported;
 2710            }
 2711
 02712            return reasons;
 2713        }
 2714
 2715        private static int GetBitDepthCompensatedBitrate(int bitrate, MediaStream videoStream, int targetBitDepth)
 2716        {
 02717            if (targetBitDepth >= 10
 02718                || (videoStream.BitDepth is int bitDepth && bitDepth <= targetBitDepth)
 02719                || videoStream.BitRate is not int sourceBitrate)
 2720            {
 02721                return bitrate;
 2722            }
 2723
 2724            // Bit depth reduction requires bit rate compensation because
 2725            // 10-bit encoded video is significantly more efficient.
 02726            var factor = sourceBitrate switch
 02727            {
 02728                <= 4_000_000 => 1.5,
 02729                <= 8_000_000 => 1.2,
 02730                <= 12_000_000 => 1.1,
 02731                _ => 1.05
 02732            };
 2733
 02734            return Convert.ToInt32(bitrate * factor);
 2735        }
 2736
 2737        public int GetVideoBitrateParamValue(BaseEncodingJobOptions request, MediaStream videoStream, string outputVideo
 2738        {
 02739            var bitrate = request.VideoBitRate;
 2740
 02741            if (videoStream is not null)
 2742            {
 02743                var isUpscaling = request.Height.HasValue
 02744                    && videoStream.Height.HasValue
 02745                    && request.Height.Value > videoStream.Height.Value
 02746                    && request.Width.HasValue
 02747                    && videoStream.Width.HasValue
 02748                    && request.Width.Value > videoStream.Width.Value;
 2749
 2750                // Don't allow bitrate increases unless upscaling
 02751                if (!isUpscaling && bitrate.HasValue && videoStream.BitRate.HasValue)
 2752                {
 02753                    bitrate = GetMinBitrate(videoStream.BitRate.Value, bitrate.Value);
 2754                }
 2755
 02756                if (bitrate.HasValue)
 2757                {
 02758                    var inputVideoCodec = videoStream.Codec;
 02759                    bitrate = GetBitDepthCompensatedBitrate(bitrate.Value, videoStream, 8);
 02760                    bitrate = ScaleBitrate(bitrate.Value, inputVideoCodec, outputVideoCodec);
 2761
 2762                    // If a max bitrate was requested, don't let the scaled bitrate exceed it
 02763                    if (request.VideoBitRate.HasValue)
 2764                    {
 02765                        bitrate = Math.Min(bitrate.Value, request.VideoBitRate.Value);
 2766                    }
 2767                }
 2768            }
 2769
 2770            // Cap the max target bitrate to 400 Mbps.
 2771            // No consumer or professional hardware transcode target exceeds this value
 2772            // (Intel QSV tops out at ~300 Mbps for H.264; HEVC High Tier Level 5.x is ~240 Mbps).
 2773            // Without this cap, plugin-provided MPEG-TS streams with no usable bitrate metadata
 2774            // can produce unreasonably large -bufsize/-maxrate values for the encoder.
 2775            // Note: the existing FallbackMaxStreamingBitrate mechanism (default 30 Mbps) only
 2776            // applies when a LiveStreamId is set (M3U/HDHR sources). Plugin streams and other
 2777            // sources that bypass the LiveTV pipeline are not covered by it.
 2778            const int MaxSaneBitrate = 400_000_000; // 400 Mbps
 02779            return Math.Min(bitrate ?? 0, MaxSaneBitrate);
 2780        }
 2781
 2782        private int GetMinBitrate(int sourceBitrate, int requestedBitrate)
 2783        {
 2784            // these values were chosen from testing to improve low bitrate streams
 02785            if (sourceBitrate <= 2000000)
 2786            {
 02787                sourceBitrate = Convert.ToInt32(sourceBitrate * 2.5);
 2788            }
 02789            else if (sourceBitrate <= 3000000)
 2790            {
 02791                sourceBitrate *= 2;
 2792            }
 2793
 02794            var bitrate = Math.Min(sourceBitrate, requestedBitrate);
 2795
 02796            return bitrate;
 2797        }
 2798
 2799        private static double GetVideoBitrateScaleFactor(string codec)
 2800        {
 2801            // hevc & vp9 - 40% more efficient than h.264
 02802            if (string.Equals(codec, "h265", StringComparison.OrdinalIgnoreCase)
 02803                || string.Equals(codec, "hevc", StringComparison.OrdinalIgnoreCase)
 02804                || string.Equals(codec, "vp9", StringComparison.OrdinalIgnoreCase))
 2805            {
 02806                return .6;
 2807            }
 2808
 2809            // av1 - 50% more efficient than h.264
 02810            if (string.Equals(codec, "av1", StringComparison.OrdinalIgnoreCase))
 2811            {
 02812                return .5;
 2813            }
 2814
 02815            return 1;
 2816        }
 2817
 2818        public static int ScaleBitrate(int bitrate, string inputVideoCodec, string outputVideoCodec)
 2819        {
 02820            var inputScaleFactor = GetVideoBitrateScaleFactor(inputVideoCodec);
 02821            var outputScaleFactor = GetVideoBitrateScaleFactor(outputVideoCodec);
 2822
 2823            // Don't scale the real bitrate lower than the requested bitrate
 02824            var scaleFactor = Math.Max(outputScaleFactor / inputScaleFactor, 1);
 2825
 02826            if (bitrate <= 500000)
 2827            {
 02828                scaleFactor = Math.Max(scaleFactor, 4);
 2829            }
 02830            else if (bitrate <= 1000000)
 2831            {
 02832                scaleFactor = Math.Max(scaleFactor, 3);
 2833            }
 02834            else if (bitrate <= 2000000)
 2835            {
 02836                scaleFactor = Math.Max(scaleFactor, 2.5);
 2837            }
 02838            else if (bitrate <= 3000000)
 2839            {
 02840                scaleFactor = Math.Max(scaleFactor, 2);
 2841            }
 02842            else if (bitrate >= 30000000)
 2843            {
 2844                // Don't scale beyond 30Mbps, it is hardly visually noticeable for most codecs with our prefer speed enc
 2845                // and will cause extremely high bitrate to be used for av1->h264 transcoding that will overload clients
 02846                scaleFactor = 1;
 2847            }
 2848
 02849            return Convert.ToInt32(scaleFactor * bitrate);
 2850        }
 2851
 2852        public int? GetAudioBitrateParam(BaseEncodingJobOptions request, MediaStream audioStream, int? outputAudioChanne
 2853        {
 02854            return GetAudioBitrateParam(request.AudioBitRate, request.AudioCodec, audioStream, outputAudioChannels);
 2855        }
 2856
 2857        public int? GetAudioBitrateParam(int? audioBitRate, string audioCodec, MediaStream audioStream, int? outputAudio
 2858        {
 232859            if (audioStream is null)
 2860            {
 02861                return null;
 2862            }
 2863
 232864            var inputChannels = audioStream.Channels ?? 0;
 232865            var outputChannels = outputAudioChannels ?? 0;
 232866            var bitrate = audioBitRate ?? int.MaxValue;
 2867
 232868            if (string.IsNullOrEmpty(audioCodec)
 232869                || string.Equals(audioCodec, "aac", StringComparison.OrdinalIgnoreCase)
 232870                || string.Equals(audioCodec, "mp3", StringComparison.OrdinalIgnoreCase)
 232871                || string.Equals(audioCodec, "opus", StringComparison.OrdinalIgnoreCase)
 232872                || string.Equals(audioCodec, "vorbis", StringComparison.OrdinalIgnoreCase)
 232873                || string.Equals(audioCodec, "ac3", StringComparison.OrdinalIgnoreCase)
 232874                || string.Equals(audioCodec, "eac3", StringComparison.OrdinalIgnoreCase))
 2875            {
 2876#pragma warning disable SA1008
 232877                return (inputChannels, outputChannels) switch
 232878                {
 02879                    ( >= 6, >= 6 or 0) => Math.Min(640000, bitrate),
 232880                    ( > 0, > 0) => Math.Min(outputChannels * 128000, bitrate),
 02881                    ( > 0, _) => Math.Min(inputChannels * 128000, bitrate),
 02882                    (_, _) => Math.Min(384000, bitrate)
 232883                };
 2884#pragma warning restore SA1008
 2885            }
 2886
 02887            if (string.Equals(audioCodec, "dts", StringComparison.OrdinalIgnoreCase)
 02888                || string.Equals(audioCodec, "dca", StringComparison.OrdinalIgnoreCase))
 2889            {
 2890#pragma warning disable SA1008
 02891                return (inputChannels, outputChannels) switch
 02892                {
 02893                    ( >= 6, >= 6 or 0) => Math.Min(768000, bitrate),
 02894                    ( > 0, > 0) => Math.Min(outputChannels * 136000, bitrate),
 02895                    ( > 0, _) => Math.Min(inputChannels * 136000, bitrate),
 02896                    (_, _) => Math.Min(672000, bitrate)
 02897                };
 2898#pragma warning restore SA1008
 2899            }
 2900
 2901            // Empty bitrate area is not allow on iOS
 2902            // Default audio bitrate to 128K per channel if we don't have codec specific defaults
 2903            // https://ffmpeg.org/ffmpeg-codecs.html#toc-Codec-Options
 02904            return 128000 * (outputAudioChannels ?? audioStream.Channels ?? 2);
 2905        }
 2906
 2907        public string GetAudioVbrModeParam(string encoder, int bitrate, int channels)
 2908        {
 02909            var bitratePerChannel = bitrate / Math.Max(channels, 1);
 02910            if (string.Equals(encoder, "libfdk_aac", StringComparison.OrdinalIgnoreCase))
 2911            {
 02912                return " -vbr:a " + bitratePerChannel switch
 02913                {
 02914                    < 32000 => "1",
 02915                    < 48000 => "2",
 02916                    < 64000 => "3",
 02917                    < 96000 => "4",
 02918                    _ => "5"
 02919                };
 2920            }
 2921
 02922            if (string.Equals(encoder, "libmp3lame", StringComparison.OrdinalIgnoreCase))
 2923            {
 2924                // lame's VBR is only good for a certain bitrate range
 2925                // For very low and very high bitrate, use abr mode
 02926                if (bitratePerChannel is < 122500 and > 48000)
 2927                {
 02928                    return " -qscale:a " + bitratePerChannel switch
 02929                    {
 02930                        < 64000 => "6",
 02931                        < 88000 => "4",
 02932                        < 112000 => "2",
 02933                        _ => "0"
 02934                    };
 2935                }
 2936
 02937                return " -abr:a 1" + " -b:a " + bitrate;
 2938            }
 2939
 02940            if (string.Equals(encoder, "aac_at", StringComparison.OrdinalIgnoreCase))
 2941            {
 2942                // aac_at's CVBR mode
 02943                return " -aac_at_mode:a 2" + " -b:a " + bitrate;
 2944            }
 2945
 02946            if (string.Equals(encoder, "libvorbis", StringComparison.OrdinalIgnoreCase))
 2947            {
 02948                return " -qscale:a " + bitratePerChannel switch
 02949                {
 02950                    < 40000 => "0",
 02951                    < 56000 => "2",
 02952                    < 80000 => "4",
 02953                    < 112000 => "6",
 02954                    _ => "8"
 02955                };
 2956            }
 2957
 02958            return null;
 2959        }
 2960
 2961        public string GetAudioFilterParam(EncodingJobInfo state, EncodingOptions encodingOptions)
 2962        {
 172963            var channels = state.OutputAudioChannels;
 2964
 172965            var filters = new List<string>();
 2966
 172967            if (channels is 2 && state.AudioStream?.Channels is > 2)
 2968            {
 22969                var hasDownMixFilter = DownMixAlgorithmsHelper.AlgorithmFilterStrings.TryGetValue((encodingOptions.DownM
 22970                if (hasDownMixFilter)
 2971                {
 22972                    filters.Add(downMixFilterString);
 2973                }
 2974
 22975                if (!encodingOptions.DownMixAudioBoost.Equals(1))
 2976                {
 12977                    filters.Add("volume=" + encodingOptions.DownMixAudioBoost.ToString(CultureInfo.InvariantCulture));
 2978                }
 2979            }
 2980
 172981            var isCopyingTimestamps = state.CopyTimestamps || state.TranscodingType != TranscodingJobType.Progressive;
 172982            if (state.SubtitleStream is not null && state.SubtitleStream.IsTextSubtitleStream && ShouldEncodeSubtitle(st
 2983            {
 02984                var seconds = TimeSpan.FromTicks(state.StartTimeTicks ?? 0).TotalSeconds;
 2985
 02986                filters.Add(
 02987                    string.Format(
 02988                        CultureInfo.InvariantCulture,
 02989                        "asetpts=PTS-{0}/TB",
 02990                        Math.Round(seconds)));
 2991            }
 2992
 172993            if (filters.Count > 0)
 2994            {
 22995                return " -af \"" + string.Join(',', filters) + "\"";
 2996            }
 2997
 152998            return string.Empty;
 2999        }
 3000
 3001        /// <summary>
 3002        /// Gets the number of audio channels to specify on the command line.
 3003        /// </summary>
 3004        /// <param name="state">The state.</param>
 3005        /// <param name="audioStream">The audio stream.</param>
 3006        /// <param name="outputAudioCodec">The output audio codec.</param>
 3007        /// <returns>System.Nullable{System.Int32}.</returns>
 3008        public int? GetNumAudioChannelsParam(EncodingJobInfo state, MediaStream audioStream, string outputAudioCodec)
 3009        {
 233010            if (audioStream is null)
 3011            {
 03012                return null;
 3013            }
 3014
 233015            var request = state.BaseRequest;
 3016
 233017            var codec = outputAudioCodec ?? string.Empty;
 3018
 233019            int? resultChannels = state.GetRequestedAudioChannels(codec);
 3020
 233021            var inputChannels = audioStream.Channels;
 3022
 233023            if (inputChannels > 0)
 3024            {
 233025                resultChannels = inputChannels < resultChannels ? inputChannels : resultChannels ?? inputChannels;
 3026            }
 3027
 233028            var isTranscodingAudio = !IsCopyCodec(codec);
 3029
 233030            if (isTranscodingAudio)
 3031            {
 233032                var audioEncoder = GetAudioEncoder(state);
 233033                if (!_audioTranscodeChannelLookup.TryGetValue(audioEncoder, out var transcoderChannelLimit))
 3034                {
 3035                    // Set default max transcoding channels to 8 to prevent encoding errors due to asking for too many c
 233036                    transcoderChannelLimit = 8;
 3037                }
 3038
 3039                // Set resultChannels to minimum between resultChannels, TranscodingMaxAudioChannels, transcoderChannelL
 233040                resultChannels = transcoderChannelLimit < resultChannels ? transcoderChannelLimit : resultChannels ?? tr
 3041
 233042                if (request.TranscodingMaxAudioChannels < resultChannels)
 3043                {
 03044                    resultChannels = request.TranscodingMaxAudioChannels;
 3045                }
 3046
 3047                // Avoid transcoding to audio channels other than 1ch, 2ch, 6ch (5.1 layout) and 8ch (7.1 layout).
 3048                // https://developer.apple.com/documentation/http_live_streaming/hls_authoring_specification_for_apple_d
 233049                if (state.TranscodingType != TranscodingJobType.Progressive
 233050                    && ((resultChannels > 2 && resultChannels < 6) || resultChannels == 7))
 3051                {
 3052                    // We can let FFMpeg supply an extra LFE channel for 5ch and 7ch to make them 5.1 and 7.1
 03053                    if (resultChannels == 5)
 3054                    {
 03055                        resultChannels = 6;
 3056                    }
 03057                    else if (resultChannels == 7)
 3058                    {
 03059                        resultChannels = 8;
 3060                    }
 3061                    else
 3062                    {
 3063                        // For other weird layout, just downmix to stereo for compatibility
 03064                        resultChannels = 2;
 3065                    }
 3066                }
 3067            }
 3068
 233069            return resultChannels;
 3070        }
 3071
 3072        /// <summary>
 3073        /// Enforces the resolution limit.
 3074        /// </summary>
 3075        /// <param name="state">The state.</param>
 3076        public void EnforceResolutionLimit(EncodingJobInfo state)
 3077        {
 03078            var videoRequest = state.BaseRequest;
 3079
 3080            // Switch the incoming params to be ceilings rather than fixed values
 03081            videoRequest.MaxWidth = videoRequest.MaxWidth ?? videoRequest.Width;
 03082            videoRequest.MaxHeight = videoRequest.MaxHeight ?? videoRequest.Height;
 3083
 03084            videoRequest.Width = null;
 03085            videoRequest.Height = null;
 03086        }
 3087
 3088        /// <summary>
 3089        /// Gets the fast seek command line parameter.
 3090        /// </summary>
 3091        /// <param name="state">The state.</param>
 3092        /// <param name="options">The options.</param>
 3093        /// <param name="segmentContainer">Segment Container.</param>
 3094        /// <returns>System.String.</returns>
 3095        /// <value>The fast seek command line parameter.</value>
 3096        public string GetFastSeekCommandLineParameter(EncodingJobInfo state, EncodingOptions options, string segmentCont
 3097        {
 183098            var time = state.BaseRequest.StartTimeTicks ?? 0;
 183099            var maxTime = state.RunTimeTicks ?? 0;
 183100            var seekParam = string.Empty;
 3101
 183102            if (time > 0)
 3103            {
 3104                // For direct streaming/remuxing, HLS segments start at keyframes.
 3105                // However, ffmpeg will seek to previous keyframe when the exact frame time is the input
 3106                // Workaround this by adding 0.5s offset to the seeking time to get the exact keyframe on most videos.
 3107                // This will help subtitle syncing.
 03108                var isHlsRemuxing = state.IsVideoRequest && state.TranscodingType is TranscodingJobType.Hls && IsCopyCod
 03109                var seekTick = isHlsRemuxing ? time + 5000000L : time;
 3110
 3111                // Seeking beyond EOF makes no sense in transcoding. Clamp the seekTick value to
 3112                // [0, RuntimeTicks - 5.0s], so that the muxer gets packets and avoid error codes.
 03113                if (maxTime > 0)
 3114                {
 03115                    seekTick = Math.Clamp(seekTick, 0, Math.Max(maxTime - 50000000L, 0));
 3116                }
 3117
 03118                seekParam += string.Format(CultureInfo.InvariantCulture, "-ss {0}", _mediaEncoder.GetTimeParameter(seekT
 3119            }
 3120
 183121            return seekParam;
 3122        }
 3123
 3124        /// <summary>
 3125        /// Gets the map args.
 3126        /// </summary>
 3127        /// <param name="state">The state.</param>
 3128        /// <returns>System.String.</returns>
 3129        public string GetMapArgs(EncodingJobInfo state)
 3130        {
 3131            // If we don't have known media info
 3132            // If input is video, use -sn to drop subtitles
 3133            // Otherwise just return empty
 73134            if (state.VideoStream is null && state.AudioStream is null)
 3135            {
 03136                return state.IsInputVideo ? "-sn" : string.Empty;
 3137            }
 3138
 3139            // We have media info, but we don't know the stream index
 73140            if (state.VideoStream is not null && state.VideoStream.Index == -1)
 3141            {
 03142                return "-sn";
 3143            }
 3144
 3145            // We have media info, but we don't know the stream index
 73146            if (state.AudioStream is not null && state.AudioStream.Index == -1)
 3147            {
 03148                return state.IsInputVideo ? "-sn" : string.Empty;
 3149            }
 3150
 73151            var args = string.Empty;
 3152
 73153            if (state.VideoStream is not null)
 3154            {
 73155                int videoStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.VideoStream);
 3156
 73157                args += string.Format(
 73158                    CultureInfo.InvariantCulture,
 73159                    "-map 0:{0}",
 73160                    videoStreamIndex);
 3161            }
 3162            else
 3163            {
 3164                // No known video stream
 03165                args += "-vn";
 3166            }
 3167
 73168            if (state.AudioStream is not null)
 3169            {
 73170                int audioStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.AudioStream);
 73171                if (state.AudioStream.IsExternal)
 3172                {
 03173                    bool hasExternalSubAsInput = NeedsExternalSubtitleMuxing(state);
 03174                    int externalAudioMapIndex = hasExternalSubAsInput ? 2 : 1;
 3175
 03176                    args += string.Format(
 03177                        CultureInfo.InvariantCulture,
 03178                        " -map {0}:{1}",
 03179                        externalAudioMapIndex,
 03180                        audioStreamIndex);
 3181                }
 3182                else
 3183                {
 73184                    args += string.Format(
 73185                        CultureInfo.InvariantCulture,
 73186                        " -map 0:{0}",
 73187                        audioStreamIndex);
 3188                }
 3189            }
 3190            else
 3191            {
 03192                args += " -map -0:a";
 3193            }
 3194
 73195            var subtitleMethod = state.SubtitleDeliveryMethod;
 73196            if (state.SubtitleStream is null || subtitleMethod == SubtitleDeliveryMethod.Hls)
 3197            {
 13198                args += " -map -0:s";
 3199            }
 63200            else if (subtitleMethod == SubtitleDeliveryMethod.Embed)
 3201            {
 63202                if (state.SubtitleStream.IsExternal)
 3203                {
 3204                    // External subtitle file is added as second FFmpeg input.
 3205                    // For single-stream files (SRT/ASS/VTT) the in-file index is always 0.
 3206                    // For multi-stream containers (MKS) we count how many streams from
 3207                    // the same file appear before the selected one.
 43208                    var inFileIndex = state.MediaSource.MediaStreams
 43209                        .Where(s => string.Equals(s.Path, state.SubtitleStream.Path, StringComparison.Ordinal))
 43210                        .TakeWhile(s => s.Index != state.SubtitleStream.Index)
 43211                        .Count();
 3212
 43213                    args += string.Format(
 43214                        CultureInfo.InvariantCulture,
 43215                        " -map 1:{0}",
 43216                        inFileIndex);
 3217                }
 3218                else
 3219                {
 23220                    int subtitleStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.SubtitleStream);
 3221
 23222                    args += string.Format(
 23223                        CultureInfo.InvariantCulture,
 23224                        " -map 0:{0}",
 23225                        subtitleStreamIndex);
 3226                }
 3227            }
 03228            else if (state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)
 3229            {
 03230                int externalSubtitleStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.SubtitleStream);
 3231
 03232                args += string.Format(
 03233                    CultureInfo.InvariantCulture,
 03234                    " -map 1:{0} -sn",
 03235                    externalSubtitleStreamIndex);
 3236            }
 3237
 73238            return args;
 3239        }
 3240
 3241        /// <summary>
 3242        /// Gets the negative map args by filters.
 3243        /// </summary>
 3244        /// <param name="state">The state.</param>
 3245        /// <param name="videoProcessFilters">The videoProcessFilters.</param>
 3246        /// <returns>System.String.</returns>
 3247        public string GetNegativeMapArgsByFilters(EncodingJobInfo state, string videoProcessFilters)
 3248        {
 03249            string args = string.Empty;
 3250
 3251            // http://ffmpeg.org/ffmpeg-all.html#toc-Complex-filtergraphs-1
 03252            if (state.VideoStream is not null && videoProcessFilters.Contains("-filter_complex", StringComparison.Ordina
 3253            {
 03254                int videoStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.VideoStream);
 3255
 03256                args += string.Format(
 03257                    CultureInfo.InvariantCulture,
 03258                    "-map -0:{0} ",
 03259                    videoStreamIndex);
 3260            }
 3261
 03262            return args;
 3263        }
 3264
 3265        /// <summary>
 3266        /// Determines which stream will be used for playback.
 3267        /// </summary>
 3268        /// <param name="allStream">All stream.</param>
 3269        /// <param name="desiredIndex">Index of the desired.</param>
 3270        /// <param name="type">The type.</param>
 3271        /// <param name="returnFirstIfNoIndex">if set to <c>true</c> [return first if no index].</param>
 3272        /// <returns>MediaStream.</returns>
 3273        public MediaStream GetMediaStream(IEnumerable<MediaStream> allStream, int? desiredIndex, MediaStreamType type, b
 3274        {
 233275            var streams = allStream.Where(s => s.Type == type).OrderBy(i => i.Index).ToList();
 3276
 233277            if (desiredIndex.HasValue)
 3278            {
 03279                var stream = streams.FirstOrDefault(s => s.Index == desiredIndex.Value);
 3280
 03281                if (stream is not null)
 3282                {
 03283                    return stream;
 3284                }
 3285            }
 3286
 233287            if (returnFirstIfNoIndex && type == MediaStreamType.Audio)
 3288            {
 233289                return streams.FirstOrDefault(i => i.Channels.HasValue && i.Channels.Value > 0) ??
 233290                       streams.FirstOrDefault();
 3291            }
 3292
 3293            // Just return the first one
 03294            return returnFirstIfNoIndex ? streams.FirstOrDefault() : null;
 3295        }
 3296
 3297        public static (int? Width, int? Height) GetFixedOutputSize(
 3298            int? videoWidth,
 3299            int? videoHeight,
 3300            int? requestedWidth,
 3301            int? requestedHeight,
 3302            int? requestedMaxWidth,
 3303            int? requestedMaxHeight)
 3304        {
 03305            if (!videoWidth.HasValue && !requestedWidth.HasValue)
 3306            {
 03307                return (null, null);
 3308            }
 3309
 03310            if (!videoHeight.HasValue && !requestedHeight.HasValue)
 3311            {
 03312                return (null, null);
 3313            }
 3314
 03315            int inputWidth = Convert.ToInt32(videoWidth ?? requestedWidth, CultureInfo.InvariantCulture);
 03316            int inputHeight = Convert.ToInt32(videoHeight ?? requestedHeight, CultureInfo.InvariantCulture);
 03317            int outputWidth = requestedWidth ?? inputWidth;
 03318            int outputHeight = requestedHeight ?? inputHeight;
 3319
 3320            // Don't transcode video to bigger than 4k when using HW.
 03321            int maximumWidth = Math.Min(requestedMaxWidth ?? outputWidth, 4096);
 03322            int maximumHeight = Math.Min(requestedMaxHeight ?? outputHeight, 4096);
 3323
 03324            if (outputWidth > maximumWidth || outputHeight > maximumHeight)
 3325            {
 03326                var scaleW = (double)maximumWidth / outputWidth;
 03327                var scaleH = (double)maximumHeight / outputHeight;
 03328                var scale = Math.Min(scaleW, scaleH);
 03329                outputWidth = Math.Min(maximumWidth, Convert.ToInt32(outputWidth * scale));
 03330                outputHeight = Math.Min(maximumHeight, Convert.ToInt32(outputHeight * scale));
 3331            }
 3332
 03333            outputWidth = 2 * (outputWidth / 2);
 03334            outputHeight = 2 * (outputHeight / 2);
 3335
 03336            return (outputWidth, outputHeight);
 3337        }
 3338
 3339        public static bool IsScaleRatioSupported(
 3340            int? videoWidth,
 3341            int? videoHeight,
 3342            int? requestedWidth,
 3343            int? requestedHeight,
 3344            int? requestedMaxWidth,
 3345            int? requestedMaxHeight,
 3346            double? maxScaleRatio)
 3347        {
 03348            var (outWidth, outHeight) = GetFixedOutputSize(
 03349                videoWidth,
 03350                videoHeight,
 03351                requestedWidth,
 03352                requestedHeight,
 03353                requestedMaxWidth,
 03354                requestedMaxHeight);
 3355
 03356            if (!videoWidth.HasValue
 03357                 || !videoHeight.HasValue
 03358                 || !outWidth.HasValue
 03359                 || !outHeight.HasValue
 03360                 || !maxScaleRatio.HasValue
 03361                 || (maxScaleRatio.Value < 1.0f))
 3362            {
 03363                return false;
 3364            }
 3365
 03366            var minScaleRatio = 1.0f / maxScaleRatio;
 03367            var scaleRatioW = (double)outWidth / (double)videoWidth;
 03368            var scaleRatioH = (double)outHeight / (double)videoHeight;
 3369
 03370            if (scaleRatioW < minScaleRatio
 03371                || scaleRatioW > maxScaleRatio
 03372                || scaleRatioH < minScaleRatio
 03373                || scaleRatioH > maxScaleRatio)
 3374            {
 03375                return false;
 3376            }
 3377
 03378            return true;
 3379        }
 3380
 3381        public static string GetHwScaleFilter(
 3382            string hwScalePrefix,
 3383            string hwScaleSuffix,
 3384            string videoFormat,
 3385            bool swapOutputWandH,
 3386            int? videoWidth,
 3387            int? videoHeight,
 3388            int? requestedWidth,
 3389            int? requestedHeight,
 3390            int? requestedMaxWidth,
 3391            int? requestedMaxHeight)
 3392        {
 03393            var (outWidth, outHeight) = GetFixedOutputSize(
 03394                videoWidth,
 03395                videoHeight,
 03396                requestedWidth,
 03397                requestedHeight,
 03398                requestedMaxWidth,
 03399                requestedMaxHeight);
 3400
 03401            var isFormatFixed = !string.IsNullOrEmpty(videoFormat);
 03402            var isSizeFixed = !videoWidth.HasValue
 03403                || outWidth.Value != videoWidth.Value
 03404                || !videoHeight.HasValue
 03405                || outHeight.Value != videoHeight.Value;
 3406
 03407            var swpOutW = swapOutputWandH ? outHeight.Value : outWidth.Value;
 03408            var swpOutH = swapOutputWandH ? outWidth.Value : outHeight.Value;
 3409
 03410            var arg1 = isSizeFixed ? $"=w={swpOutW}:h={swpOutH}" : string.Empty;
 03411            var arg2 = isFormatFixed ? $"format={videoFormat}" : string.Empty;
 03412            if (isFormatFixed)
 3413            {
 03414                arg2 = (isSizeFixed ? ':' : '=') + arg2;
 3415            }
 3416
 03417            if (!string.IsNullOrEmpty(hwScaleSuffix) && (isSizeFixed || isFormatFixed))
 3418            {
 03419                return string.Format(
 03420                    CultureInfo.InvariantCulture,
 03421                    "{0}_{1}{2}{3}",
 03422                    hwScalePrefix ?? "scale",
 03423                    hwScaleSuffix,
 03424                    arg1,
 03425                    arg2);
 3426            }
 3427
 03428            return string.Empty;
 3429        }
 3430
 3431        public static string GetGraphicalSubPreProcessFilters(
 3432            int? videoWidth,
 3433            int? videoHeight,
 3434            int? subtitleWidth,
 3435            int? subtitleHeight,
 3436            int? requestedWidth,
 3437            int? requestedHeight,
 3438            int? requestedMaxWidth,
 3439            int? requestedMaxHeight)
 3440        {
 03441            var (outWidth, outHeight) = GetFixedOutputSize(
 03442                videoWidth,
 03443                videoHeight,
 03444                requestedWidth,
 03445                requestedHeight,
 03446                requestedMaxWidth,
 03447                requestedMaxHeight);
 3448
 03449            if (!outWidth.HasValue
 03450                || !outHeight.HasValue
 03451                || outWidth.Value <= 0
 03452                || outHeight.Value <= 0)
 3453            {
 03454                return string.Empty;
 3455            }
 3456
 3457            // Automatically add padding based on subtitle input
 03458            var filters = @"scale,scale=-1:{1}:fast_bilinear,crop,pad=max({0}\,iw):max({1}\,ih):(ow-iw)/2:(oh-ih)/2:blac
 3459
 03460            if (subtitleWidth.HasValue
 03461                && subtitleHeight.HasValue
 03462                && subtitleWidth.Value > 0
 03463                && subtitleHeight.Value > 0)
 3464            {
 03465                var videoDar = (double)outWidth.Value / outHeight.Value;
 03466                var subtitleDar = (double)subtitleWidth.Value / subtitleHeight.Value;
 3467
 3468                // No need to add padding when DAR is the same -> 1080p PGSSUB on 2160p video
 03469                if (Math.Abs(videoDar - subtitleDar) < 0.01f)
 3470                {
 03471                    filters = @"scale,scale={0}:{1}:fast_bilinear";
 3472                }
 3473            }
 3474
 03475            return string.Format(
 03476                CultureInfo.InvariantCulture,
 03477                filters,
 03478                outWidth.Value,
 03479                outHeight.Value);
 3480        }
 3481
 3482        public static string GetAlphaSrcFilter(
 3483            EncodingJobInfo state,
 3484            int? videoWidth,
 3485            int? videoHeight,
 3486            int? requestedWidth,
 3487            int? requestedHeight,
 3488            int? requestedMaxWidth,
 3489            int? requestedMaxHeight,
 3490            float? framerate)
 3491        {
 03492            var reqTicks = state.BaseRequest.StartTimeTicks ?? 0;
 03493            var startTime = TimeSpan.FromTicks(reqTicks).ToString(@"hh\\\:mm\\\:ss\\\.fff", CultureInfo.InvariantCulture
 03494            var (outWidth, outHeight) = GetFixedOutputSize(
 03495                videoWidth,
 03496                videoHeight,
 03497                requestedWidth,
 03498                requestedHeight,
 03499                requestedMaxWidth,
 03500                requestedMaxHeight);
 3501
 03502            if (outWidth.HasValue && outHeight.HasValue)
 3503            {
 03504                return string.Format(
 03505                    CultureInfo.InvariantCulture,
 03506                    "alphasrc=s={0}x{1}:r={2}:start='{3}'",
 03507                    outWidth.Value,
 03508                    outHeight.Value,
 03509                    framerate ?? 25,
 03510                    reqTicks > 0 ? startTime : 0);
 3511            }
 3512
 03513            return string.Empty;
 3514        }
 3515
 3516        public static string GetSwScaleFilter(
 3517            EncodingJobInfo state,
 3518            EncodingOptions options,
 3519            string videoEncoder,
 3520            int? videoWidth,
 3521            int? videoHeight,
 3522            Video3DFormat? threedFormat,
 3523            int? requestedWidth,
 3524            int? requestedHeight,
 3525            int? requestedMaxWidth,
 3526            int? requestedMaxHeight)
 3527        {
 63528            var isV4l2 = string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase);
 63529            var isMjpeg = videoEncoder is not null && videoEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase)
 63530            var scaleVal = isV4l2 ? 64 : 2;
 63531            var targetAr = isMjpeg ? "(a*sar)" : "a"; // manually calculate AR when using mjpeg encoder
 3532
 3533            // If fixed dimensions were supplied
 63534            if (requestedWidth.HasValue && requestedHeight.HasValue)
 3535            {
 03536                if (isV4l2)
 3537                {
 03538                    var widthParam = requestedWidth.Value.ToString(CultureInfo.InvariantCulture);
 03539                    var heightParam = requestedHeight.Value.ToString(CultureInfo.InvariantCulture);
 3540
 03541                    return string.Format(
 03542                            CultureInfo.InvariantCulture,
 03543                            "scale=trunc({0}/64)*64:trunc({1}/2)*2",
 03544                            widthParam,
 03545                            heightParam);
 3546                }
 3547
 03548                return GetFixedSwScaleFilter(threedFormat, requestedWidth.Value, requestedHeight.Value);
 3549            }
 3550
 3551            // If Max dimensions were supplied, for width selects lowest even number between input width and width req s
 3552
 63553            if (requestedMaxWidth.HasValue && requestedMaxHeight.HasValue)
 3554            {
 03555                var maxWidthParam = requestedMaxWidth.Value.ToString(CultureInfo.InvariantCulture);
 03556                var maxHeightParam = requestedMaxHeight.Value.ToString(CultureInfo.InvariantCulture);
 3557
 03558                return string.Format(
 03559                    CultureInfo.InvariantCulture,
 03560                    @"scale=trunc(min(max(iw\,ih*{3})\,min({0}\,{1}*{3}))/{2})*{2}:trunc(min(max(iw/{3}\,ih)\,min({0}/{3
 03561                    maxWidthParam,
 03562                    maxHeightParam,
 03563                    scaleVal,
 03564                    targetAr);
 3565            }
 3566
 3567            // If a fixed width was requested
 63568            if (requestedWidth.HasValue)
 3569            {
 03570                if (threedFormat.HasValue)
 3571                {
 3572                    // This method can handle 0 being passed in for the requested height
 03573                    return GetFixedSwScaleFilter(threedFormat, requestedWidth.Value, 0);
 3574                }
 3575
 03576                var widthParam = requestedWidth.Value.ToString(CultureInfo.InvariantCulture);
 3577
 03578                return string.Format(
 03579                    CultureInfo.InvariantCulture,
 03580                    "scale={0}:trunc(ow/{1}/2)*2",
 03581                    widthParam,
 03582                    targetAr);
 3583            }
 3584
 3585            // If a fixed height was requested
 63586            if (requestedHeight.HasValue)
 3587            {
 03588                var heightParam = requestedHeight.Value.ToString(CultureInfo.InvariantCulture);
 3589
 03590                return string.Format(
 03591                    CultureInfo.InvariantCulture,
 03592                    "scale=trunc(oh*{2}/{1})*{1}:{0}",
 03593                    heightParam,
 03594                    scaleVal,
 03595                    targetAr);
 3596            }
 3597
 3598            // If a max width was requested
 63599            if (requestedMaxWidth.HasValue)
 3600            {
 03601                var maxWidthParam = requestedMaxWidth.Value.ToString(CultureInfo.InvariantCulture);
 3602
 03603                return string.Format(
 03604                    CultureInfo.InvariantCulture,
 03605                    @"scale=trunc(min(max(iw\,ih*{2})\,{0})/{1})*{1}:trunc(ow/{2}/2)*2",
 03606                    maxWidthParam,
 03607                    scaleVal,
 03608                    targetAr);
 3609            }
 3610
 3611            // If a max height was requested
 63612            if (requestedMaxHeight.HasValue)
 3613            {
 03614                var maxHeightParam = requestedMaxHeight.Value.ToString(CultureInfo.InvariantCulture);
 3615
 03616                return string.Format(
 03617                    CultureInfo.InvariantCulture,
 03618                    @"scale=trunc(oh*{2}/{1})*{1}:min(max(iw/{2}\,ih)\,{0})",
 03619                    maxHeightParam,
 03620                    scaleVal,
 03621                    targetAr);
 3622            }
 3623
 63624            return string.Empty;
 3625        }
 3626
 3627        private static string GetFixedSwScaleFilter(Video3DFormat? threedFormat, int requestedWidth, int requestedHeight
 3628        {
 03629            var widthParam = requestedWidth.ToString(CultureInfo.InvariantCulture);
 03630            var heightParam = requestedHeight.ToString(CultureInfo.InvariantCulture);
 3631
 03632            string filter = null;
 3633
 03634            if (threedFormat.HasValue)
 3635            {
 03636                switch (threedFormat.Value)
 3637                {
 3638                    case Video3DFormat.HalfSideBySide:
 03639                        filter = @"crop=iw/2:ih:0:0,scale=(iw*2):ih,setdar=dar=a,crop=min(iw\,ih*dar):min(ih\,iw/dar):(i
 3640                        // hsbs crop width in half,scale to correct size, set the display aspect,crop out any black bars
 03641                        break;
 3642                    case Video3DFormat.FullSideBySide:
 03643                        filter = @"crop=iw/2:ih:0:0,setdar=dar=a,crop=min(iw\,ih*dar):min(ih\,iw/dar):(iw-min(iw\,iw*sar
 3644                        // fsbs crop width in half,set the display aspect,crop out any black bars we may have made the s
 03645                        break;
 3646                    case Video3DFormat.HalfTopAndBottom:
 03647                        filter = @"crop=iw:ih/2:0:0,scale=(iw*2):ih),setdar=dar=a,crop=min(iw\,ih*dar):min(ih\,iw/dar):(
 3648                        // htab crop height in half,scale to correct size, set the display aspect,crop out any black bar
 03649                        break;
 3650                    case Video3DFormat.FullTopAndBottom:
 03651                        filter = @"crop=iw:ih/2:0:0,setdar=dar=a,crop=min(iw\,ih*dar):min(ih\,iw/dar):(iw-min(iw\,iw*sar
 3652                        // ftab crop height in half, set the display aspect,crop out any black bars we may have made the
 3653                        break;
 3654                    default:
 3655                        break;
 3656                }
 3657            }
 3658
 3659            // default
 03660            if (filter is null)
 3661            {
 03662                if (requestedHeight > 0)
 3663                {
 03664                    filter = "scale=trunc({0}/2)*2:trunc({1}/2)*2";
 3665                }
 3666                else
 3667                {
 03668                    filter = "scale={0}:trunc({0}/a/2)*2";
 3669                }
 3670            }
 3671
 03672            return string.Format(CultureInfo.InvariantCulture, filter, widthParam, heightParam);
 3673        }
 3674
 3675        public static string GetSwDeinterlaceFilter(EncodingJobInfo state, EncodingOptions options)
 3676        {
 03677            var doubleRateDeint = options.DeinterlaceDoubleRate && state.VideoStream?.ReferenceFrameRate <= 30;
 03678            return string.Format(
 03679                CultureInfo.InvariantCulture,
 03680                "{0}={1}:-1:0",
 03681                options.DeinterlaceMethod.ToString().ToLowerInvariant(),
 03682                doubleRateDeint ? "1" : "0");
 3683        }
 3684
 3685        public string GetHwDeinterlaceFilter(EncodingJobInfo state, EncodingOptions options, string hwDeintSuffix)
 3686        {
 03687            var doubleRateDeint = options.DeinterlaceDoubleRate && (state.VideoStream?.ReferenceFrameRate ?? 60) <= 30;
 03688            if (hwDeintSuffix.Contains("cuda", StringComparison.OrdinalIgnoreCase))
 3689            {
 03690                var useBwdif = options.DeinterlaceMethod == DeinterlaceMethod.bwdif && _mediaEncoder.SupportsFilter("bwd
 3691
 03692                return string.Format(
 03693                    CultureInfo.InvariantCulture,
 03694                    "{0}_cuda={1}:-1:0",
 03695                    useBwdif ? "bwdif" : "yadif",
 03696                    doubleRateDeint ? "1" : "0");
 3697            }
 3698
 03699            if (hwDeintSuffix.Contains("opencl", StringComparison.OrdinalIgnoreCase))
 3700            {
 03701                var useBwdif = options.DeinterlaceMethod == DeinterlaceMethod.bwdif;
 3702
 03703                if (_mediaEncoder.SupportsFilter("yadif_opencl")
 03704                    && _mediaEncoder.SupportsFilter("bwdif_opencl"))
 3705                {
 03706                    return string.Format(
 03707                        CultureInfo.InvariantCulture,
 03708                        "{0}_opencl={1}:-1:0",
 03709                        useBwdif ? "bwdif" : "yadif",
 03710                        doubleRateDeint ? "1" : "0");
 3711                }
 3712            }
 3713
 03714            if (hwDeintSuffix.Contains("vaapi", StringComparison.OrdinalIgnoreCase))
 3715            {
 03716                return string.Format(
 03717                    CultureInfo.InvariantCulture,
 03718                    "deinterlace_vaapi=rate={0}",
 03719                    doubleRateDeint ? "field" : "frame");
 3720            }
 3721
 03722            if (hwDeintSuffix.Contains("qsv", StringComparison.OrdinalIgnoreCase))
 3723            {
 03724                return "deinterlace_qsv=mode=2";
 3725            }
 3726
 03727            if (hwDeintSuffix.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase))
 3728            {
 03729                var useBwdif = options.DeinterlaceMethod == DeinterlaceMethod.bwdif && _mediaEncoder.SupportsFilter("bwd
 3730
 03731                return string.Format(
 03732                    CultureInfo.InvariantCulture,
 03733                    "{0}_videotoolbox={1}:-1:0",
 03734                    useBwdif ? "bwdif" : "yadif",
 03735                    doubleRateDeint ? "1" : "0");
 3736            }
 3737
 03738            return string.Empty;
 3739        }
 3740
 3741        private string GetHwTonemapFilter(EncodingOptions options, string hwTonemapSuffix, string videoFormat, bool forc
 3742        {
 03743            if (string.IsNullOrEmpty(hwTonemapSuffix))
 3744            {
 03745                return string.Empty;
 3746            }
 3747
 03748            var args = string.Empty;
 03749            var algorithm = options.TonemappingAlgorithm.ToString().ToLowerInvariant();
 03750            var mode = options.TonemappingMode.ToString().ToLowerInvariant();
 03751            var range = forceFullRange ? TonemappingRange.pc : options.TonemappingRange;
 03752            var rangeString = range.ToString().ToLowerInvariant();
 3753
 03754            if (string.Equals(hwTonemapSuffix, "vaapi", StringComparison.OrdinalIgnoreCase))
 3755            {
 03756                var doVaVppProcamp = false;
 03757                var procampParams = string.Empty;
 03758                if (options.VppTonemappingBrightness != 0
 03759                    && options.VppTonemappingBrightness >= -100
 03760                    && options.VppTonemappingBrightness <= 100)
 3761                {
 03762                    procampParams += "procamp_vaapi=b={0}";
 03763                    doVaVppProcamp = true;
 3764                }
 3765
 03766                if (options.VppTonemappingContrast > 1
 03767                    && options.VppTonemappingContrast <= 10)
 3768                {
 03769                    procampParams += doVaVppProcamp ? ":c={1}" : "procamp_vaapi=c={1}";
 03770                    doVaVppProcamp = true;
 3771                }
 3772
 03773                args = procampParams + "{2}tonemap_vaapi=format={3}:p=bt709:t=bt709:m=bt709:extra_hw_frames=32";
 3774
 03775                return string.Format(
 03776                        CultureInfo.InvariantCulture,
 03777                        args,
 03778                        options.VppTonemappingBrightness,
 03779                        options.VppTonemappingContrast,
 03780                        doVaVppProcamp ? "," : string.Empty,
 03781                        videoFormat ?? "nv12");
 3782            }
 3783            else
 3784            {
 03785                args = "tonemap_{0}=format={1}:p=bt709:t=bt709:m=bt709:tonemap={2}:peak={3}:desat={4}";
 3786
 03787                var useLegacyTonemapModes = _mediaEncoder.EncoderVersion >= _minFFmpegOclCuTonemapMode
 03788                                           && _legacyTonemapModes.Contains(options.TonemappingMode);
 3789
 03790                var useAdvancedTonemapModes = _mediaEncoder.EncoderVersion >= _minFFmpegAdvancedTonemapMode
 03791                                              && _advancedTonemapModes.Contains(options.TonemappingMode);
 3792
 03793                if (useLegacyTonemapModes || useAdvancedTonemapModes)
 3794                {
 03795                    args += ":tonemap_mode={5}";
 3796                }
 3797
 03798                if (options.TonemappingParam != 0)
 3799                {
 03800                    args += ":param={6}";
 3801                }
 3802
 03803                if (range == TonemappingRange.tv || range == TonemappingRange.pc)
 3804                {
 03805                    args += ":range={7}";
 3806                }
 3807            }
 3808
 03809            return string.Format(
 03810                    CultureInfo.InvariantCulture,
 03811                    args,
 03812                    hwTonemapSuffix,
 03813                    videoFormat ?? "nv12",
 03814                    algorithm,
 03815                    options.TonemappingPeak,
 03816                    options.TonemappingDesat,
 03817                    mode,
 03818                    options.TonemappingParam,
 03819                    rangeString);
 3820        }
 3821
 3822        private string GetLibplaceboFilter(
 3823            EncodingOptions options,
 3824            string videoFormat,
 3825            bool doTonemap,
 3826            int? videoWidth,
 3827            int? videoHeight,
 3828            int? requestedWidth,
 3829            int? requestedHeight,
 3830            int? requestedMaxWidth,
 3831            int? requestedMaxHeight,
 3832            bool forceFullRange)
 3833        {
 03834            var (outWidth, outHeight) = GetFixedOutputSize(
 03835                videoWidth,
 03836                videoHeight,
 03837                requestedWidth,
 03838                requestedHeight,
 03839                requestedMaxWidth,
 03840                requestedMaxHeight);
 3841
 03842            var isFormatFixed = !string.IsNullOrEmpty(videoFormat);
 03843            var isSizeFixed = !videoWidth.HasValue
 03844                || outWidth.Value != videoWidth.Value
 03845                || !videoHeight.HasValue
 03846                || outHeight.Value != videoHeight.Value;
 3847
 03848            var sizeArg = isSizeFixed ? (":w=" + outWidth.Value + ":h=" + outHeight.Value) : string.Empty;
 03849            var formatArg = isFormatFixed ? (":format=" + videoFormat) : string.Empty;
 03850            var tonemapArg = string.Empty;
 3851
 3852            // libplacebo only support full range RGB
 03853            forceFullRange = forceFullRange
 03854                || (videoFormat ?? string.Empty).Contains("rgb", StringComparison.OrdinalIgnoreCase)
 03855                || (videoFormat ?? string.Empty).Contains("bgr", StringComparison.OrdinalIgnoreCase);
 3856
 03857            if (doTonemap)
 3858            {
 03859                var algorithm = options.TonemappingAlgorithm;
 03860                var algorithmString = "clip";
 03861                var mode = options.TonemappingMode;
 03862                var range = forceFullRange ? TonemappingRange.pc : options.TonemappingRange;
 3863
 03864                if (algorithm == TonemappingAlgorithm.bt2390)
 3865                {
 03866                    algorithmString = "bt.2390";
 3867                }
 03868                else if (algorithm != TonemappingAlgorithm.none)
 3869                {
 03870                    algorithmString = algorithm.ToString().ToLowerInvariant();
 3871                }
 3872
 03873                tonemapArg = $":tonemapping={algorithmString}:peak_detect=0:color_primaries=bt709:color_trc=bt709:colors
 3874
 03875                if (range == TonemappingRange.tv || range == TonemappingRange.pc)
 3876                {
 03877                    tonemapArg += ":range=" + range.ToString().ToLowerInvariant();
 3878                }
 3879            }
 03880            else if (forceFullRange)
 3881            {
 03882                formatArg += ":range=pc";
 3883            }
 3884
 03885            return string.Format(
 03886                CultureInfo.InvariantCulture,
 03887                "libplacebo=upscaler=none:downscaler=none{0}{1}{2}",
 03888                sizeArg,
 03889                formatArg,
 03890                tonemapArg);
 3891        }
 3892
 3893        public string GetVideoTransposeDirection(EncodingJobInfo state)
 3894        {
 03895            return (state.VideoStream?.Rotation ?? 0) switch
 03896            {
 03897                90 => "cclock",
 03898                180 => "reversal",
 03899                -90 => "clock",
 03900                -180 => "reversal",
 03901                _ => string.Empty
 03902            };
 3903        }
 3904
 3905        /// <summary>
 3906        /// Gets the parameter of software filter chain.
 3907        /// </summary>
 3908        /// <param name="state">Encoding state.</param>
 3909        /// <param name="options">Encoding options.</param>
 3910        /// <param name="vidEncoder">Video encoder to use.</param>
 3911        /// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>
 3912        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetSwVidFilterChain(
 3913            EncodingJobInfo state,
 3914            EncodingOptions options,
 3915            string vidEncoder)
 3916        {
 63917            var inW = state.VideoStream?.Width;
 63918            var inH = state.VideoStream?.Height;
 63919            var reqW = state.BaseRequest.Width;
 63920            var reqH = state.BaseRequest.Height;
 63921            var reqMaxW = state.BaseRequest.MaxWidth;
 63922            var reqMaxH = state.BaseRequest.MaxHeight;
 63923            var threeDFormat = state.MediaSource.Video3DFormat;
 3924
 63925            var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 63926            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 63927            var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 63928            var isV4l2Encoder = vidEncoder.Contains("h264_v4l2m2m", StringComparison.OrdinalIgnoreCase);
 3929
 63930            var doDeintH2645 = IsDeinterlaceAvailable(state);
 63931            var doToneMap = IsSwTonemapAvailable(state, options);
 63932            var requireDoviReshaping = doToneMap && state.VideoStream.VideoRangeType == VideoRangeType.DOVI;
 3933
 63934            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 63935            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 63936            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 3937
 63938            var rotation = state.VideoStream?.Rotation ?? 0;
 63939            var swapWAndH = Math.Abs(rotation) == 90;
 63940            var swpInW = swapWAndH ? inH : inW;
 63941            var swpInH = swapWAndH ? inW : inH;
 3942
 3943            /* Make main filters for video stream */
 63944            var mainFilters = new List<string>();
 3945
 63946            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doToneMap));
 3947
 3948            // INPUT sw surface(memory/copy-back from vram)
 3949            // sw deint
 63950            if (doDeintH2645)
 3951            {
 03952                var deintFilter = GetSwDeinterlaceFilter(state, options);
 03953                mainFilters.Add(deintFilter);
 3954            }
 3955
 63956            var outFormat = isSwDecoder ? "yuv420p" : "nv12";
 63957            var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, reqH, r
 63958            if (isVaapiEncoder)
 3959            {
 03960                outFormat = "nv12";
 3961            }
 63962            else if (isV4l2Encoder)
 3963            {
 03964                outFormat = "yuv420p";
 3965            }
 3966
 3967            // sw scale
 63968            mainFilters.Add(swScaleFilter);
 3969
 3970            // sw tonemap
 63971            if (doToneMap)
 3972            {
 3973                // tonemapx requires yuv420p10 input for dovi reshaping, let ffmpeg convert the frame when necessary
 23974                var tonemapFormat = requireDoviReshaping ? "yuv420p" : outFormat;
 23975                var tonemapArgString = "tonemapx=tonemap={0}:desat={1}:peak={2}:t=bt709:m=bt709:p=bt709:format={3}";
 3976
 23977                if (options.TonemappingParam != 0)
 3978                {
 03979                    tonemapArgString += ":param={4}";
 3980                }
 3981
 23982                var range = options.TonemappingRange;
 23983                if (range == TonemappingRange.tv || range == TonemappingRange.pc)
 3984                {
 03985                    tonemapArgString += ":range={5}";
 3986                }
 3987
 23988                var tonemapArgs = string.Format(
 23989                    CultureInfo.InvariantCulture,
 23990                    tonemapArgString,
 23991                    options.TonemappingAlgorithm,
 23992                    options.TonemappingDesat,
 23993                    options.TonemappingPeak,
 23994                    tonemapFormat,
 23995                    options.TonemappingParam,
 23996                    options.TonemappingRange);
 3997
 23998                mainFilters.Add(tonemapArgs);
 3999            }
 4000            else
 4001            {
 4002                // OUTPUT yuv420p/nv12 surface(memory)
 44003                mainFilters.Add("format=" + outFormat);
 4004            }
 4005
 4006            /* Make sub and overlay filters for subtitle stream */
 64007            var subFilters = new List<string>();
 64008            var overlayFilters = new List<string>();
 64009            if (hasTextSubs)
 4010            {
 4011                // subtitles=f='*.ass':alpha=0
 04012                var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);
 04013                mainFilters.Add(textSubtitlesFilter);
 4014            }
 64015            else if (hasGraphicalSubs)
 4016            {
 04017                var subW = state.SubtitleStream?.Width;
 04018                var subH = state.SubtitleStream?.Height;
 04019                var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, reqMaxW
 04020                subFilters.Add(subPreProcFilters);
 04021                overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");
 4022            }
 4023
 64024            return (mainFilters, subFilters, overlayFilters);
 4025        }
 4026
 4027        /// <summary>
 4028        /// Gets the parameter of Nvidia NVENC filter chain.
 4029        /// </summary>
 4030        /// <param name="state">Encoding state.</param>
 4031        /// <param name="options">Encoding options.</param>
 4032        /// <param name="vidEncoder">Video encoder to use.</param>
 4033        /// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>
 4034        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetNvidiaVidFilterChain(
 4035            EncodingJobInfo state,
 4036            EncodingOptions options,
 4037            string vidEncoder)
 4038        {
 04039            if (options.HardwareAccelerationType != HardwareAccelerationType.nvenc)
 4040            {
 04041                return (null, null, null);
 4042            }
 4043
 04044            var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 04045            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 04046            var isSwEncoder = !vidEncoder.Contains("nvenc", StringComparison.OrdinalIgnoreCase);
 4047
 4048            // legacy cuvid pipeline(copy-back)
 04049            if ((isSwDecoder && isSwEncoder)
 04050                || !IsCudaFullSupported()
 04051                || !_mediaEncoder.SupportsFilter("alphasrc"))
 4052            {
 04053                return GetSwVidFilterChain(state, options, vidEncoder);
 4054            }
 4055
 4056            // preferred nvdec/cuvid + cuda filters + nvenc pipeline
 04057            return GetNvidiaVidFiltersPrefered(state, options, vidDecoder, vidEncoder);
 4058        }
 4059
 4060        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetNvidiaVidFiltersPrefe
 4061            EncodingJobInfo state,
 4062            EncodingOptions options,
 4063            string vidDecoder,
 4064            string vidEncoder)
 4065        {
 04066            var inW = state.VideoStream?.Width;
 04067            var inH = state.VideoStream?.Height;
 04068            var reqW = state.BaseRequest.Width;
 04069            var reqH = state.BaseRequest.Height;
 04070            var reqMaxW = state.BaseRequest.MaxWidth;
 04071            var reqMaxH = state.BaseRequest.MaxHeight;
 04072            var threeDFormat = state.MediaSource.Video3DFormat;
 4073
 04074            var isNvDecoder = vidDecoder.Contains("cuda", StringComparison.OrdinalIgnoreCase);
 04075            var isNvencEncoder = vidEncoder.Contains("nvenc", StringComparison.OrdinalIgnoreCase);
 04076            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 04077            var isSwEncoder = !isNvencEncoder;
 04078            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 04079            var isCuInCuOut = isNvDecoder && isNvencEncoder;
 4080
 04081            var doubleRateDeint = options.DeinterlaceDoubleRate && (state.VideoStream?.ReferenceFrameRate ?? 60) <= 30;
 04082            var doDeintH2645 = IsDeinterlaceAvailable(state);
 04083            var doCuTonemap = IsHwTonemapAvailable(state, options);
 4084
 04085            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 04086            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 04087            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 04088            var hasAssSubs = hasSubs
 04089                && (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)
 04090                    || string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));
 04091            var subW = state.SubtitleStream?.Width;
 04092            var subH = state.SubtitleStream?.Height;
 4093
 04094            var rotation = state.VideoStream?.Rotation ?? 0;
 04095            var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);
 04096            var doCuTranspose = !string.IsNullOrEmpty(transposeDir) && _mediaEncoder.SupportsFilter("transpose_cuda");
 04097            var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder || (isNvDecoder && doCuTranspose));
 04098            var swpInW = swapWAndH ? inH : inW;
 04099            var swpInH = swapWAndH ? inW : inH;
 4100
 4101            /* Make main filters for video stream */
 04102            var mainFilters = new List<string>();
 4103
 04104            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doCuTonemap));
 4105
 04106            if (isSwDecoder)
 4107            {
 4108                // INPUT sw surface(memory)
 4109                // sw deint
 04110                if (doDeintH2645)
 4111                {
 04112                    var swDeintFilter = GetSwDeinterlaceFilter(state, options);
 04113                    mainFilters.Add(swDeintFilter);
 4114                }
 4115
 04116                var outFormat = doCuTonemap ? "p010le" : "yuv420p";
 04117                var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req
 4118                // sw scale
 04119                mainFilters.Add(swScaleFilter);
 04120                mainFilters.Add($"format={outFormat}");
 4121
 4122                // sw => hw
 04123                if (doCuTonemap)
 4124                {
 04125                    mainFilters.Add("hwupload=derive_device=cuda");
 4126                }
 4127            }
 4128
 04129            if (isNvDecoder)
 4130            {
 4131                // INPUT cuda surface(vram)
 4132                // hw deint
 04133                if (doDeintH2645)
 4134                {
 04135                    var deintFilter = GetHwDeinterlaceFilter(state, options, "cuda");
 04136                    mainFilters.Add(deintFilter);
 4137                }
 4138
 4139                // hw transpose
 04140                if (doCuTranspose)
 4141                {
 04142                    mainFilters.Add($"transpose_cuda=dir={transposeDir}");
 4143                }
 4144
 04145                var isRext = IsVideoStreamHevcRext(state);
 04146                var outFormat = doCuTonemap ? (isRext ? "p010" : string.Empty) : "yuv420p";
 04147                var hwScaleFilter = GetHwScaleFilter("scale", "cuda", outFormat, false, swpInW, swpInH, reqW, reqH, reqM
 4148                // hw scale
 04149                mainFilters.Add(hwScaleFilter);
 4150            }
 4151
 4152            // hw tonemap
 04153            if (doCuTonemap)
 4154            {
 04155                var tonemapFilter = GetHwTonemapFilter(options, "cuda", "yuv420p", isMjpegEncoder);
 04156                mainFilters.Add(tonemapFilter);
 4157            }
 4158
 04159            var memoryOutput = false;
 04160            var isUploadForCuTonemap = isSwDecoder && doCuTonemap;
 04161            if ((isNvDecoder && isSwEncoder) || (isUploadForCuTonemap && hasSubs))
 4162            {
 04163                memoryOutput = true;
 4164
 4165                // OUTPUT yuv420p surface(memory)
 04166                mainFilters.Add("hwdownload");
 04167                mainFilters.Add("format=yuv420p");
 4168            }
 4169
 4170            // OUTPUT yuv420p surface(memory)
 04171            if (isSwDecoder && isNvencEncoder && !isUploadForCuTonemap)
 4172            {
 04173                memoryOutput = true;
 4174            }
 4175
 04176            if (memoryOutput)
 4177            {
 4178                // text subtitles
 04179                if (hasTextSubs)
 4180                {
 04181                    var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);
 04182                    mainFilters.Add(textSubtitlesFilter);
 4183                }
 4184            }
 4185
 4186            // OUTPUT cuda(yuv420p) surface(vram)
 4187
 4188            /* Make sub and overlay filters for subtitle stream */
 04189            var subFilters = new List<string>();
 04190            var overlayFilters = new List<string>();
 04191            if (isCuInCuOut)
 4192            {
 04193                if (hasSubs)
 4194                {
 04195                    var alphaFormatOpt = string.Empty;
 04196                    if (hasGraphicalSubs)
 4197                    {
 04198                        var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,
 04199                        subFilters.Add(subPreProcFilters);
 04200                        subFilters.Add("format=yuva420p");
 4201                    }
 04202                    else if (hasTextSubs)
 4203                    {
 04204                        var framerate = state.VideoStream?.RealFrameRate;
 04205                        var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;
 4206
 4207                        // alphasrc=s=1280x720:r=10:start=0,format=yuva420p,subtitles,hwupload
 04208                        var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH, subF
 04209                        var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);
 04210                        subFilters.Add(alphaSrcFilter);
 04211                        subFilters.Add("format=yuva420p");
 04212                        subFilters.Add(subTextSubtitlesFilter);
 4213
 04214                        alphaFormatOpt = _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayCudaAlphaFormat)
 04215                            ? ":alpha_format=premultiplied" : string.Empty;
 4216                    }
 4217
 04218                    subFilters.Add("hwupload=derive_device=cuda");
 04219                    overlayFilters.Add($"overlay_cuda=eof_action=pass:repeatlast=0{alphaFormatOpt}");
 4220                }
 4221            }
 4222            else
 4223            {
 04224                if (hasGraphicalSubs)
 4225                {
 04226                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 04227                    subFilters.Add(subPreProcFilters);
 04228                    overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");
 4229                }
 4230            }
 4231
 04232            return (mainFilters, subFilters, overlayFilters);
 4233        }
 4234
 4235        /// <summary>
 4236        /// Gets the parameter of AMD AMF filter chain.
 4237        /// </summary>
 4238        /// <param name="state">Encoding state.</param>
 4239        /// <param name="options">Encoding options.</param>
 4240        /// <param name="vidEncoder">Video encoder to use.</param>
 4241        /// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>
 4242        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAmdVidFilterChain(
 4243            EncodingJobInfo state,
 4244            EncodingOptions options,
 4245            string vidEncoder)
 4246        {
 04247            if (options.HardwareAccelerationType != HardwareAccelerationType.amf)
 4248            {
 04249                return (null, null, null);
 4250            }
 4251
 04252            var isWindows = OperatingSystem.IsWindows();
 04253            var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 04254            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 04255            var isSwEncoder = !vidEncoder.Contains("amf", StringComparison.OrdinalIgnoreCase);
 04256            var isAmfDx11OclSupported = isWindows && _mediaEncoder.SupportsHwaccel("d3d11va") && IsOpenclFullSupported()
 4257
 4258            // legacy d3d11va pipeline(copy-back)
 04259            if ((isSwDecoder && isSwEncoder)
 04260                || !isAmfDx11OclSupported
 04261                || !_mediaEncoder.SupportsFilter("alphasrc"))
 4262            {
 04263                return GetSwVidFilterChain(state, options, vidEncoder);
 4264            }
 4265
 4266            // preferred d3d11va + opencl filters + amf pipeline
 04267            return GetAmdDx11VidFiltersPrefered(state, options, vidDecoder, vidEncoder);
 4268        }
 4269
 4270        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAmdDx11VidFiltersPref
 4271            EncodingJobInfo state,
 4272            EncodingOptions options,
 4273            string vidDecoder,
 4274            string vidEncoder)
 4275        {
 04276            var inW = state.VideoStream?.Width;
 04277            var inH = state.VideoStream?.Height;
 04278            var reqW = state.BaseRequest.Width;
 04279            var reqH = state.BaseRequest.Height;
 04280            var reqMaxW = state.BaseRequest.MaxWidth;
 04281            var reqMaxH = state.BaseRequest.MaxHeight;
 04282            var threeDFormat = state.MediaSource.Video3DFormat;
 4283
 04284            var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);
 04285            var isAmfEncoder = vidEncoder.Contains("amf", StringComparison.OrdinalIgnoreCase);
 04286            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 04287            var isSwEncoder = !isAmfEncoder;
 04288            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 04289            var isDxInDxOut = isD3d11vaDecoder && isAmfEncoder;
 4290
 04291            var doDeintH2645 = IsDeinterlaceAvailable(state);
 04292            var doOclTonemap = IsHwTonemapAvailable(state, options);
 4293
 04294            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 04295            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 04296            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 04297            var hasAssSubs = hasSubs
 04298                && (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)
 04299                    || string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));
 04300            var subW = state.SubtitleStream?.Width;
 04301            var subH = state.SubtitleStream?.Height;
 4302
 04303            var rotation = state.VideoStream?.Rotation ?? 0;
 04304            var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);
 04305            var doOclTranspose = !string.IsNullOrEmpty(transposeDir)
 04306                && _mediaEncoder.SupportsFilterWithOption(FilterOptionType.TransposeOpenclReversal);
 04307            var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder || (isD3d11vaDecoder && doOclTranspose));
 04308            var swpInW = swapWAndH ? inH : inW;
 04309            var swpInH = swapWAndH ? inW : inH;
 4310
 4311            /* Make main filters for video stream */
 04312            var mainFilters = new List<string>();
 4313
 04314            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doOclTonemap));
 4315
 04316            if (isSwDecoder)
 4317            {
 4318                // INPUT sw surface(memory)
 4319                // sw deint
 04320                if (doDeintH2645)
 4321                {
 04322                    var swDeintFilter = GetSwDeinterlaceFilter(state, options);
 04323                    mainFilters.Add(swDeintFilter);
 4324                }
 4325
 04326                var outFormat = doOclTonemap ? "yuv420p10le" : "yuv420p";
 04327                var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req
 4328                // sw scale
 04329                mainFilters.Add(swScaleFilter);
 04330                mainFilters.Add($"format={outFormat}");
 4331
 4332                // keep video at memory except ocl tonemap,
 4333                // since the overhead caused by hwupload >>> using sw filter.
 4334                // sw => hw
 04335                if (doOclTonemap)
 4336                {
 04337                    mainFilters.Add("hwupload=derive_device=d3d11va:extra_hw_frames=24");
 04338                    mainFilters.Add("format=d3d11");
 04339                    mainFilters.Add("hwmap=derive_device=opencl:mode=read");
 4340                }
 4341            }
 4342
 04343            if (isD3d11vaDecoder)
 4344            {
 4345                // INPUT d3d11 surface(vram)
 4346                // map from d3d11va to opencl via d3d11-opencl interop.
 04347                mainFilters.Add("hwmap=derive_device=opencl:mode=read");
 4348
 4349                // hw deint
 04350                if (doDeintH2645)
 4351                {
 04352                    var deintFilter = GetHwDeinterlaceFilter(state, options, "opencl");
 04353                    mainFilters.Add(deintFilter);
 4354                }
 4355
 4356                // hw transpose
 04357                if (doOclTranspose)
 4358                {
 04359                    mainFilters.Add($"transpose_opencl=dir={transposeDir}");
 4360                }
 4361
 04362                var outFormat = doOclTonemap ? string.Empty : "nv12";
 04363                var hwScaleFilter = GetHwScaleFilter("scale", "opencl", outFormat, false, swpInW, swpInH, reqW, reqH, re
 4364                // hw scale
 04365                mainFilters.Add(hwScaleFilter);
 4366            }
 4367
 4368            // hw tonemap
 04369            if (doOclTonemap)
 4370            {
 04371                var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);
 04372                mainFilters.Add(tonemapFilter);
 4373            }
 4374
 04375            var memoryOutput = false;
 04376            var isUploadForOclTonemap = isSwDecoder && doOclTonemap;
 04377            if (isD3d11vaDecoder && isSwEncoder)
 4378            {
 04379                memoryOutput = true;
 4380
 4381                // OUTPUT nv12 surface(memory)
 4382                // prefer hwmap to hwdownload on opencl.
 04383                var hwTransferFilter = hasGraphicalSubs ? "hwdownload" : "hwmap=mode=read";
 04384                mainFilters.Add(hwTransferFilter);
 04385                mainFilters.Add("format=nv12");
 4386            }
 4387
 4388            // OUTPUT yuv420p surface
 04389            if (isSwDecoder && isAmfEncoder && !isUploadForOclTonemap)
 4390            {
 04391                memoryOutput = true;
 4392            }
 4393
 04394            if (memoryOutput)
 4395            {
 4396                // text subtitles
 04397                if (hasTextSubs)
 4398                {
 04399                    var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);
 04400                    mainFilters.Add(textSubtitlesFilter);
 4401                }
 4402            }
 4403
 04404            if ((isDxInDxOut || isUploadForOclTonemap) && !hasSubs)
 4405            {
 4406                // OUTPUT d3d11(nv12) surface(vram)
 4407                // reverse-mapping via d3d11-opencl interop.
 04408                mainFilters.Add("hwmap=derive_device=d3d11va:mode=write:reverse=1");
 04409                mainFilters.Add("format=d3d11");
 4410            }
 4411
 4412            /* Make sub and overlay filters for subtitle stream */
 04413            var subFilters = new List<string>();
 04414            var overlayFilters = new List<string>();
 04415            if (isDxInDxOut || isUploadForOclTonemap)
 4416            {
 04417                if (hasSubs)
 4418                {
 04419                    var alphaFormatOpt = string.Empty;
 04420                    if (hasGraphicalSubs)
 4421                    {
 04422                        var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,
 04423                        subFilters.Add(subPreProcFilters);
 04424                        subFilters.Add("format=yuva420p");
 4425                    }
 04426                    else if (hasTextSubs)
 4427                    {
 04428                        var framerate = state.VideoStream?.RealFrameRate;
 04429                        var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;
 4430
 4431                        // alphasrc=s=1280x720:r=10:start=0,format=yuva420p,subtitles,hwupload
 04432                        var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH, subF
 04433                        var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);
 04434                        subFilters.Add(alphaSrcFilter);
 04435                        subFilters.Add("format=yuva420p");
 04436                        subFilters.Add(subTextSubtitlesFilter);
 4437
 04438                        alphaFormatOpt = _mediaEncoder.SupportsFilterWithOption(FilterOptionType.OverlayOpenclAlphaForma
 04439                            ? ":alpha_format=premultiplied" : string.Empty;
 4440                    }
 4441
 04442                    subFilters.Add("hwupload=derive_device=opencl");
 04443                    overlayFilters.Add($"overlay_opencl=eof_action=pass:repeatlast=0{alphaFormatOpt}");
 04444                    overlayFilters.Add("hwmap=derive_device=d3d11va:mode=write:reverse=1");
 04445                    overlayFilters.Add("format=d3d11");
 4446                }
 4447            }
 04448            else if (memoryOutput)
 4449            {
 04450                if (hasGraphicalSubs)
 4451                {
 04452                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 04453                    subFilters.Add(subPreProcFilters);
 04454                    overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");
 4455                }
 4456            }
 4457
 04458            return (mainFilters, subFilters, overlayFilters);
 4459        }
 4460
 4461        /// <summary>
 4462        /// Gets the parameter of Intel QSV filter chain.
 4463        /// </summary>
 4464        /// <param name="state">Encoding state.</param>
 4465        /// <param name="options">Encoding options.</param>
 4466        /// <param name="vidEncoder">Video encoder to use.</param>
 4467        /// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>
 4468        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetIntelVidFilterChain(
 4469            EncodingJobInfo state,
 4470            EncodingOptions options,
 4471            string vidEncoder)
 4472        {
 04473            if (options.HardwareAccelerationType != HardwareAccelerationType.qsv)
 4474            {
 04475                return (null, null, null);
 4476            }
 4477
 04478            var isWindows = OperatingSystem.IsWindows();
 04479            var isLinux = OperatingSystem.IsLinux();
 04480            var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 04481            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 04482            var isSwEncoder = !vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);
 04483            var isQsvOclSupported = _mediaEncoder.SupportsHwaccel("qsv") && IsOpenclFullSupported();
 04484            var isIntelDx11OclSupported = isWindows
 04485                && _mediaEncoder.SupportsHwaccel("d3d11va")
 04486                && isQsvOclSupported;
 04487            var isIntelVaapiOclSupported = isLinux
 04488                && IsVaapiSupported(state)
 04489                && isQsvOclSupported;
 4490
 4491            // legacy qsv pipeline(copy-back)
 04492            if ((isSwDecoder && isSwEncoder)
 04493                || (!isIntelVaapiOclSupported && !isIntelDx11OclSupported)
 04494                || !_mediaEncoder.SupportsFilter("alphasrc"))
 4495            {
 04496                return GetSwVidFilterChain(state, options, vidEncoder);
 4497            }
 4498
 4499            // preferred qsv(vaapi) + opencl filters pipeline
 04500            if (isIntelVaapiOclSupported)
 4501            {
 04502                return GetIntelQsvVaapiVidFiltersPrefered(state, options, vidDecoder, vidEncoder);
 4503            }
 4504
 4505            // preferred qsv(d3d11) + opencl filters pipeline
 04506            if (isIntelDx11OclSupported)
 4507            {
 04508                return GetIntelQsvDx11VidFiltersPrefered(state, options, vidDecoder, vidEncoder);
 4509            }
 4510
 04511            return (null, null, null);
 4512        }
 4513
 4514        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetIntelQsvDx11VidFilter
 4515            EncodingJobInfo state,
 4516            EncodingOptions options,
 4517            string vidDecoder,
 4518            string vidEncoder)
 4519        {
 04520            var inW = state.VideoStream?.Width;
 04521            var inH = state.VideoStream?.Height;
 04522            var reqW = state.BaseRequest.Width;
 04523            var reqH = state.BaseRequest.Height;
 04524            var reqMaxW = state.BaseRequest.MaxWidth;
 04525            var reqMaxH = state.BaseRequest.MaxHeight;
 04526            var threeDFormat = state.MediaSource.Video3DFormat;
 4527
 04528            var isD3d11vaDecoder = vidDecoder.Contains("d3d11va", StringComparison.OrdinalIgnoreCase);
 04529            var isQsvDecoder = vidDecoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);
 04530            var isQsvEncoder = vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);
 04531            var isHwDecoder = isD3d11vaDecoder || isQsvDecoder;
 04532            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 04533            var isSwEncoder = !isQsvEncoder;
 04534            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 04535            var isQsvInQsvOut = isHwDecoder && isQsvEncoder;
 4536
 04537            var doDeintH2645 = IsDeinterlaceAvailable(state);
 04538            var doVppTonemap = IsIntelVppTonemapAvailable(state, options);
 04539            var doOclTonemap = !doVppTonemap && IsHwTonemapAvailable(state, options);
 04540            var doTonemap = doVppTonemap || doOclTonemap;
 4541
 04542            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 04543            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 04544            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 04545            var hasAssSubs = hasSubs
 04546                && (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)
 04547                    || string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));
 04548            var subW = state.SubtitleStream?.Width;
 04549            var subH = state.SubtitleStream?.Height;
 4550
 04551            var rotation = state.VideoStream?.Rotation ?? 0;
 04552            var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);
 04553            var doVppTranspose = !string.IsNullOrEmpty(transposeDir);
 04554            var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder || ((isD3d11vaDecoder || isQsvDecoder) && doVppTran
 04555            var swpInW = swapWAndH ? inH : inW;
 04556            var swpInH = swapWAndH ? inW : inH;
 4557
 4558            /* Make main filters for video stream */
 04559            var mainFilters = new List<string>();
 4560
 04561            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doTonemap));
 4562
 04563            if (isSwDecoder)
 4564            {
 4565                // INPUT sw surface(memory)
 4566                // sw deint
 04567                if (doDeintH2645)
 4568                {
 04569                    var swDeintFilter = GetSwDeinterlaceFilter(state, options);
 04570                    mainFilters.Add(swDeintFilter);
 4571                }
 4572
 04573                var outFormat = doOclTonemap ? "yuv420p10le" : (hasGraphicalSubs ? "yuv420p" : "nv12");
 04574                var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req
 04575                if (isMjpegEncoder && !doOclTonemap)
 4576                {
 4577                    // sw decoder + hw mjpeg encoder
 04578                    swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r
 4579                }
 4580
 4581                // sw scale
 04582                mainFilters.Add(swScaleFilter);
 04583                mainFilters.Add($"format={outFormat}");
 4584
 4585                // keep video at memory except ocl tonemap,
 4586                // since the overhead caused by hwupload >>> using sw filter.
 4587                // sw => hw
 04588                if (doOclTonemap)
 4589                {
 04590                    mainFilters.Add("hwupload=derive_device=opencl");
 4591                }
 4592            }
 04593            else if (isD3d11vaDecoder || isQsvDecoder)
 4594            {
 04595                var isRext = IsVideoStreamHevcRext(state);
 04596                var twoPassVppTonemap = false;
 04597                var doVppFullRangeOut = isMjpegEncoder
 04598                    && _mediaEncoder.EncoderVersion >= _minFFmpegQsvVppOutRangeOption;
 04599                var doVppScaleModeHq = isMjpegEncoder
 04600                    && _mediaEncoder.EncoderVersion >= _minFFmpegQsvVppScaleModeOption;
 04601                var doVppProcamp = false;
 04602                var procampParams = string.Empty;
 04603                var procampParamsString = string.Empty;
 04604                if (doVppTonemap)
 4605                {
 04606                    if (isRext)
 4607                    {
 4608                        // VPP tonemap requires p010 input
 04609                        twoPassVppTonemap = true;
 4610                    }
 4611
 04612                    if (options.VppTonemappingBrightness != 0
 04613                        && options.VppTonemappingBrightness >= -100
 04614                        && options.VppTonemappingBrightness <= 100)
 4615                    {
 04616                        procampParamsString += ":brightness={0}";
 04617                        twoPassVppTonemap = doVppProcamp = true;
 4618                    }
 4619
 04620                    if (options.VppTonemappingContrast > 1
 04621                        && options.VppTonemappingContrast <= 10)
 4622                    {
 04623                        procampParamsString += ":contrast={1}";
 04624                        twoPassVppTonemap = doVppProcamp = true;
 4625                    }
 4626
 04627                    if (doVppProcamp)
 4628                    {
 04629                        procampParamsString += ":procamp=1:async_depth=2";
 04630                        procampParams = string.Format(
 04631                            CultureInfo.InvariantCulture,
 04632                            procampParamsString,
 04633                            options.VppTonemappingBrightness,
 04634                            options.VppTonemappingContrast);
 4635                    }
 4636                }
 4637
 04638                var outFormat = doOclTonemap ? ((doVppTranspose || isRext) ? "p010" : string.Empty) : "nv12";
 04639                outFormat = twoPassVppTonemap ? "p010" : outFormat;
 4640
 04641                var swapOutputWandH = doVppTranspose && swapWAndH;
 04642                var hwScaleFilter = GetHwScaleFilter("vpp", "qsv", outFormat, swapOutputWandH, swpInW, swpInH, reqW, req
 4643
 4644                // d3d11va doesn't support dynamic pool size, use vpp filter ctx to relay
 4645                // to prevent encoder async and bframes from exhausting the decoder pool.
 04646                if (!string.IsNullOrEmpty(hwScaleFilter) && isD3d11vaDecoder)
 4647                {
 04648                    hwScaleFilter += ":passthrough=0";
 4649                }
 4650
 04651                if (!string.IsNullOrEmpty(hwScaleFilter) && doVppTranspose)
 4652                {
 04653                    hwScaleFilter += $":transpose={transposeDir}";
 4654                }
 4655
 04656                if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder)
 4657                {
 04658                    hwScaleFilter += (doVppFullRangeOut && !doOclTonemap) ? ":out_range=pc" : string.Empty;
 04659                    hwScaleFilter += doVppScaleModeHq ? ":scale_mode=hq" : string.Empty;
 4660                }
 4661
 04662                if (!string.IsNullOrEmpty(hwScaleFilter) && doVppTonemap)
 4663                {
 04664                    hwScaleFilter += doVppProcamp ? procampParams : (twoPassVppTonemap ? string.Empty : ":tonemap=1");
 4665                }
 4666
 04667                if (isD3d11vaDecoder)
 4668                {
 04669                    if (!string.IsNullOrEmpty(hwScaleFilter) || doDeintH2645)
 4670                    {
 4671                        // INPUT d3d11 surface(vram)
 4672                        // map from d3d11va to qsv.
 04673                        mainFilters.Add("hwmap=derive_device=qsv");
 4674                    }
 4675                }
 4676
 4677                // hw deint
 04678                if (doDeintH2645)
 4679                {
 04680                    var deintFilter = GetHwDeinterlaceFilter(state, options, "qsv");
 04681                    mainFilters.Add(deintFilter);
 4682                }
 4683
 4684                // hw transpose & scale & tonemap(w/o procamp)
 04685                mainFilters.Add(hwScaleFilter);
 4686
 4687                // hw tonemap(w/ procamp)
 04688                if (doVppTonemap && twoPassVppTonemap)
 4689                {
 04690                    mainFilters.Add("vpp_qsv=tonemap=1:format=nv12:async_depth=2");
 4691                }
 4692
 4693                // force bt709 just in case vpp tonemap is not triggered or using MSDK instead of VPL.
 04694                if (doVppTonemap)
 4695                {
 04696                    mainFilters.Add(GetOverwriteColorPropertiesParam(state, false));
 4697                }
 4698            }
 4699
 04700            if (doOclTonemap && isHwDecoder)
 4701            {
 4702                // map from qsv to opencl via qsv(d3d11)-opencl interop.
 04703                mainFilters.Add("hwmap=derive_device=opencl:mode=read");
 4704            }
 4705
 4706            // hw tonemap
 04707            if (doOclTonemap)
 4708            {
 04709                var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);
 04710                mainFilters.Add(tonemapFilter);
 4711            }
 4712
 04713            var memoryOutput = false;
 04714            var isUploadForOclTonemap = isSwDecoder && doOclTonemap;
 04715            var isHwmapUsable = isSwEncoder && doOclTonemap;
 04716            if ((isHwDecoder && isSwEncoder) || isUploadForOclTonemap)
 4717            {
 04718                memoryOutput = true;
 4719
 4720                // OUTPUT nv12 surface(memory)
 4721                // prefer hwmap to hwdownload on opencl.
 4722                // qsv hwmap is not fully implemented for the time being.
 04723                mainFilters.Add(isHwmapUsable ? "hwmap=mode=read" : "hwdownload");
 04724                mainFilters.Add("format=nv12");
 4725            }
 4726
 4727            // OUTPUT nv12 surface(memory)
 04728            if (isSwDecoder && isQsvEncoder)
 4729            {
 04730                memoryOutput = true;
 4731            }
 4732
 04733            if (memoryOutput)
 4734            {
 4735                // text subtitles
 04736                if (hasTextSubs)
 4737                {
 04738                    var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);
 04739                    mainFilters.Add(textSubtitlesFilter);
 4740                }
 4741            }
 4742
 04743            if (isQsvInQsvOut && doOclTonemap)
 4744            {
 4745                // OUTPUT qsv(nv12) surface(vram)
 4746                // reverse-mapping via qsv(d3d11)-opencl interop.
 04747                mainFilters.Add("hwmap=derive_device=qsv:mode=write:reverse=1");
 04748                mainFilters.Add("format=qsv");
 4749            }
 4750
 4751            /* Make sub and overlay filters for subtitle stream */
 04752            var subFilters = new List<string>();
 04753            var overlayFilters = new List<string>();
 04754            if (isQsvInQsvOut)
 4755            {
 04756                if (hasSubs)
 4757                {
 04758                    if (hasGraphicalSubs)
 4759                    {
 4760                        // overlay_qsv can handle overlay scaling, setup a smaller height to reduce transfer overhead
 04761                        var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,
 04762                        subFilters.Add(subPreProcFilters);
 04763                        subFilters.Add("format=bgra");
 4764                    }
 04765                    else if (hasTextSubs)
 4766                    {
 04767                        var framerate = state.VideoStream?.RealFrameRate;
 04768                        var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;
 4769
 4770                        // alphasrc=s=1280x720:r=10:start=0,format=bgra,subtitles,hwupload
 04771                        var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, 1080, subFram
 04772                        var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);
 04773                        subFilters.Add(alphaSrcFilter);
 04774                        subFilters.Add("format=bgra");
 04775                        subFilters.Add(subTextSubtitlesFilter);
 4776                    }
 4777
 4778                    // qsv requires a fixed pool size.
 4779                    // default to 64 otherwise it will fail on certain iGPU.
 04780                    subFilters.Add("hwupload=derive_device=qsv:extra_hw_frames=64");
 4781
 04782                    var (overlayW, overlayH) = GetFixedOutputSize(swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH);
 04783                    var overlaySize = (overlayW.HasValue && overlayH.HasValue)
 04784                        ? $":w={overlayW.Value}:h={overlayH.Value}"
 04785                        : string.Empty;
 04786                    var overlayQsvFilter = string.Format(
 04787                        CultureInfo.InvariantCulture,
 04788                        "overlay_qsv=eof_action=pass:repeatlast=0{0}",
 04789                        overlaySize);
 04790                    overlayFilters.Add(overlayQsvFilter);
 4791                }
 4792            }
 04793            else if (memoryOutput)
 4794            {
 04795                if (hasGraphicalSubs)
 4796                {
 04797                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 04798                    subFilters.Add(subPreProcFilters);
 04799                    overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");
 4800                }
 4801            }
 4802
 04803            return (mainFilters, subFilters, overlayFilters);
 4804        }
 4805
 4806        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetIntelQsvVaapiVidFilte
 4807            EncodingJobInfo state,
 4808            EncodingOptions options,
 4809            string vidDecoder,
 4810            string vidEncoder)
 4811        {
 04812            var inW = state.VideoStream?.Width;
 04813            var inH = state.VideoStream?.Height;
 04814            var reqW = state.BaseRequest.Width;
 04815            var reqH = state.BaseRequest.Height;
 04816            var reqMaxW = state.BaseRequest.MaxWidth;
 04817            var reqMaxH = state.BaseRequest.MaxHeight;
 04818            var threeDFormat = state.MediaSource.Video3DFormat;
 4819
 04820            var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 04821            var isQsvDecoder = vidDecoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);
 04822            var isQsvEncoder = vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase);
 04823            var isHwDecoder = isVaapiDecoder || isQsvDecoder;
 04824            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 04825            var isSwEncoder = !isQsvEncoder;
 04826            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 04827            var isQsvInQsvOut = isHwDecoder && isQsvEncoder;
 4828
 04829            var doVaVppTonemap = IsIntelVppTonemapAvailable(state, options);
 04830            var doOclTonemap = !doVaVppTonemap && IsHwTonemapAvailable(state, options);
 04831            var doTonemap = doVaVppTonemap || doOclTonemap;
 04832            var doDeintH2645 = IsDeinterlaceAvailable(state);
 4833
 04834            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 04835            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 04836            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 04837            var hasAssSubs = hasSubs
 04838                && (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)
 04839                    || string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));
 04840            var subW = state.SubtitleStream?.Width;
 04841            var subH = state.SubtitleStream?.Height;
 4842
 04843            var rotation = state.VideoStream?.Rotation ?? 0;
 04844            var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);
 04845            var doVppTranspose = !string.IsNullOrEmpty(transposeDir);
 04846            var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder || ((isVaapiDecoder || isQsvDecoder) && doVppTransp
 04847            var swpInW = swapWAndH ? inH : inW;
 04848            var swpInH = swapWAndH ? inW : inH;
 4849
 4850            /* Make main filters for video stream */
 04851            var mainFilters = new List<string>();
 4852
 04853            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doTonemap));
 4854
 04855            if (isSwDecoder)
 4856            {
 4857                // INPUT sw surface(memory)
 4858                // sw deint
 04859                if (doDeintH2645)
 4860                {
 04861                    var swDeintFilter = GetSwDeinterlaceFilter(state, options);
 04862                    mainFilters.Add(swDeintFilter);
 4863                }
 4864
 04865                var outFormat = doOclTonemap ? "yuv420p10le" : (hasGraphicalSubs ? "yuv420p" : "nv12");
 04866                var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req
 04867                if (isMjpegEncoder && !doOclTonemap)
 4868                {
 4869                    // sw decoder + hw mjpeg encoder
 04870                    swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r
 4871                }
 4872
 4873                // sw scale
 04874                mainFilters.Add(swScaleFilter);
 04875                mainFilters.Add($"format={outFormat}");
 4876
 4877                // keep video at memory except ocl tonemap,
 4878                // since the overhead caused by hwupload >>> using sw filter.
 4879                // sw => hw
 04880                if (doOclTonemap)
 4881                {
 04882                    mainFilters.Add("hwupload=derive_device=opencl");
 4883                }
 4884            }
 04885            else if (isVaapiDecoder || isQsvDecoder)
 4886            {
 04887                var hwFilterSuffix = isVaapiDecoder ? "vaapi" : "qsv";
 04888                var isRext = IsVideoStreamHevcRext(state);
 04889                var doVppFullRangeOut = isMjpegEncoder
 04890                    && _mediaEncoder.EncoderVersion >= _minFFmpegQsvVppOutRangeOption;
 04891                var doVppScaleModeHq = isMjpegEncoder
 04892                    && _mediaEncoder.EncoderVersion >= _minFFmpegQsvVppScaleModeOption;
 4893
 4894                // INPUT vaapi/qsv surface(vram)
 4895                // hw deint
 04896                if (doDeintH2645)
 4897                {
 04898                    var deintFilter = GetHwDeinterlaceFilter(state, options, hwFilterSuffix);
 04899                    mainFilters.Add(deintFilter);
 4900                }
 4901
 4902                // hw transpose(vaapi vpp)
 04903                if (isVaapiDecoder && doVppTranspose)
 4904                {
 04905                    mainFilters.Add($"transpose_vaapi=dir={transposeDir}");
 4906                }
 4907
 04908                var outFormat = doTonemap ? (((isQsvDecoder && doVppTranspose) || isRext) ? "p010" : string.Empty) : "nv
 04909                var swapOutputWandH = isQsvDecoder && doVppTranspose && swapWAndH;
 04910                var hwScalePrefix = isQsvDecoder ? "vpp" : "scale";
 04911                var hwScaleFilter = GetHwScaleFilter(hwScalePrefix, hwFilterSuffix, outFormat, swapOutputWandH, swpInW, 
 4912
 04913                if (!string.IsNullOrEmpty(hwScaleFilter) && isQsvDecoder && doVppTranspose)
 4914                {
 04915                    hwScaleFilter += $":transpose={transposeDir}";
 4916                }
 4917
 04918                if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder)
 4919                {
 04920                    hwScaleFilter += ((isQsvDecoder && !doVppFullRangeOut) || doOclTonemap) ? string.Empty : ":out_range
 04921                    hwScaleFilter += isQsvDecoder ? (doVppScaleModeHq ? ":scale_mode=hq" : string.Empty) : ":mode=hq";
 4922                }
 4923
 4924                // allocate extra pool sizes for vaapi vpp scale
 04925                if (!string.IsNullOrEmpty(hwScaleFilter) && isVaapiDecoder)
 4926                {
 04927                    hwScaleFilter += ":extra_hw_frames=24";
 4928                }
 4929
 4930                // hw transpose(qsv vpp) & scale
 04931                mainFilters.Add(hwScaleFilter);
 4932            }
 4933
 4934            // vaapi vpp tonemap
 04935            if (doVaVppTonemap && isHwDecoder)
 4936            {
 04937                if (isQsvDecoder)
 4938                {
 4939                    // map from qsv to vaapi.
 04940                    mainFilters.Add("hwmap=derive_device=vaapi");
 04941                    mainFilters.Add("format=vaapi");
 4942                }
 4943
 04944                var tonemapFilter = GetHwTonemapFilter(options, "vaapi", "nv12", isMjpegEncoder);
 04945                mainFilters.Add(tonemapFilter);
 4946
 04947                if (isQsvDecoder)
 4948                {
 4949                    // map from vaapi to qsv.
 04950                    mainFilters.Add("hwmap=derive_device=qsv");
 04951                    mainFilters.Add("format=qsv");
 4952                }
 4953            }
 4954
 04955            if (doOclTonemap && isHwDecoder)
 4956            {
 4957                // map from qsv to opencl via qsv(vaapi)-opencl interop.
 04958                mainFilters.Add("hwmap=derive_device=opencl:mode=read");
 4959            }
 4960
 4961            // ocl tonemap
 04962            if (doOclTonemap)
 4963            {
 04964                var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);
 04965                mainFilters.Add(tonemapFilter);
 4966            }
 4967
 04968            var memoryOutput = false;
 04969            var isUploadForOclTonemap = isSwDecoder && doOclTonemap;
 04970            var isHwmapUsable = isSwEncoder && (doOclTonemap || isVaapiDecoder);
 04971            if ((isHwDecoder && isSwEncoder) || isUploadForOclTonemap)
 4972            {
 04973                memoryOutput = true;
 4974
 4975                // OUTPUT nv12 surface(memory)
 4976                // prefer hwmap to hwdownload on opencl/vaapi.
 4977                // qsv hwmap is not fully implemented for the time being.
 04978                mainFilters.Add(isHwmapUsable ? "hwmap=mode=read" : "hwdownload");
 04979                mainFilters.Add("format=nv12");
 4980            }
 4981
 4982            // OUTPUT nv12 surface(memory)
 04983            if (isSwDecoder && isQsvEncoder)
 4984            {
 04985                memoryOutput = true;
 4986            }
 4987
 04988            if (memoryOutput)
 4989            {
 4990                // text subtitles
 04991                if (hasTextSubs)
 4992                {
 04993                    var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);
 04994                    mainFilters.Add(textSubtitlesFilter);
 4995                }
 4996            }
 4997
 04998            if (isQsvInQsvOut)
 4999            {
 05000                if (doOclTonemap)
 5001                {
 5002                    // OUTPUT qsv(nv12) surface(vram)
 5003                    // reverse-mapping via qsv(vaapi)-opencl interop.
 5004                    // add extra pool size to avoid the 'cannot allocate memory' error on hevc_qsv.
 05005                    mainFilters.Add("hwmap=derive_device=qsv:mode=write:reverse=1:extra_hw_frames=16");
 05006                    mainFilters.Add("format=qsv");
 5007                }
 05008                else if (isVaapiDecoder)
 5009                {
 05010                    mainFilters.Add("hwmap=derive_device=qsv");
 05011                    mainFilters.Add("format=qsv");
 5012                }
 5013            }
 5014
 5015            /* Make sub and overlay filters for subtitle stream */
 05016            var subFilters = new List<string>();
 05017            var overlayFilters = new List<string>();
 05018            if (isQsvInQsvOut)
 5019            {
 05020                if (hasSubs)
 5021                {
 05022                    if (hasGraphicalSubs)
 5023                    {
 5024                        // overlay_qsv can handle overlay scaling, setup a smaller height to reduce transfer overhead
 05025                        var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,
 05026                        subFilters.Add(subPreProcFilters);
 05027                        subFilters.Add("format=bgra");
 5028                    }
 05029                    else if (hasTextSubs)
 5030                    {
 05031                        var framerate = state.VideoStream?.RealFrameRate;
 05032                        var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;
 5033
 05034                        var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, 1080, subFram
 05035                        var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);
 05036                        subFilters.Add(alphaSrcFilter);
 05037                        subFilters.Add("format=bgra");
 05038                        subFilters.Add(subTextSubtitlesFilter);
 5039                    }
 5040
 5041                    // qsv requires a fixed pool size.
 5042                    // default to 64 otherwise it will fail on certain iGPU.
 05043                    subFilters.Add("hwupload=derive_device=qsv:extra_hw_frames=64");
 5044
 05045                    var (overlayW, overlayH) = GetFixedOutputSize(swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH);
 05046                    var overlaySize = (overlayW.HasValue && overlayH.HasValue)
 05047                        ? $":w={overlayW.Value}:h={overlayH.Value}"
 05048                        : string.Empty;
 05049                    var overlayQsvFilter = string.Format(
 05050                        CultureInfo.InvariantCulture,
 05051                        "overlay_qsv=eof_action=pass:repeatlast=0{0}",
 05052                        overlaySize);
 05053                    overlayFilters.Add(overlayQsvFilter);
 5054                }
 5055            }
 05056            else if (memoryOutput)
 5057            {
 05058                if (hasGraphicalSubs)
 5059                {
 05060                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 05061                    subFilters.Add(subPreProcFilters);
 05062                    overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");
 5063                }
 5064            }
 5065
 05066            return (mainFilters, subFilters, overlayFilters);
 5067        }
 5068
 5069        /// <summary>
 5070        /// Gets the parameter of Intel/AMD VAAPI filter chain.
 5071        /// </summary>
 5072        /// <param name="state">Encoding state.</param>
 5073        /// <param name="options">Encoding options.</param>
 5074        /// <param name="vidEncoder">Video encoder to use.</param>
 5075        /// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>
 5076        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetVaapiVidFilterChain(
 5077            EncodingJobInfo state,
 5078            EncodingOptions options,
 5079            string vidEncoder)
 5080        {
 05081            if (options.HardwareAccelerationType != HardwareAccelerationType.vaapi)
 5082            {
 05083                return (null, null, null);
 5084            }
 5085
 05086            var isLinux = OperatingSystem.IsLinux();
 05087            var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 05088            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 05089            var isSwEncoder = !vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 05090            var isVaapiFullSupported = isLinux && IsVaapiSupported(state) && IsVaapiFullSupported();
 05091            var isVaapiOclSupported = isVaapiFullSupported && IsOpenclFullSupported();
 05092            var isVaapiVkSupported = isVaapiFullSupported && IsVulkanFullSupported();
 5093
 5094            // legacy vaapi pipeline(copy-back)
 05095            if ((isSwDecoder && isSwEncoder)
 05096                || !isVaapiOclSupported
 05097                || !_mediaEncoder.SupportsFilter("alphasrc"))
 5098            {
 05099                var swFilterChain = GetSwVidFilterChain(state, options, vidEncoder);
 5100
 05101                if (!isSwEncoder)
 5102                {
 05103                    var newfilters = new List<string>();
 05104                    var noOverlay = swFilterChain.OverlayFilters.Count == 0;
 05105                    newfilters.AddRange(noOverlay ? swFilterChain.MainFilters : swFilterChain.OverlayFilters);
 05106                    newfilters.Add("hwupload=derive_device=vaapi");
 5107
 05108                    var mainFilters = noOverlay ? newfilters : swFilterChain.MainFilters;
 05109                    var overlayFilters = noOverlay ? swFilterChain.OverlayFilters : newfilters;
 05110                    return (mainFilters, swFilterChain.SubFilters, overlayFilters);
 5111                }
 5112
 05113                return swFilterChain;
 5114            }
 5115
 5116            // preferred vaapi + opencl filters pipeline
 05117            if (_mediaEncoder.IsVaapiDeviceInteliHD)
 5118            {
 5119                // Intel iHD path, with extra vpp tonemap and overlay support.
 05120                return GetIntelVaapiFullVidFiltersPrefered(state, options, vidDecoder, vidEncoder);
 5121            }
 5122
 5123            // preferred vaapi + vulkan filters pipeline
 05124            if (_mediaEncoder.IsVaapiDeviceAmd
 05125                && isVaapiVkSupported
 05126                && _mediaEncoder.IsVaapiDeviceSupportVulkanDrmInterop
 05127                && Environment.OSVersion.Version >= _minKernelVersionAmdVkFmtModifier)
 5128            {
 5129                // AMD radeonsi path(targeting Polaris/gfx8+), with extra vulkan tonemap and overlay support.
 05130                return GetAmdVaapiFullVidFiltersPrefered(state, options, vidDecoder, vidEncoder);
 5131            }
 5132
 5133            // Intel i965 and Amd legacy driver path, only featuring scale and deinterlace support.
 05134            return GetVaapiLimitedVidFiltersPrefered(state, options, vidDecoder, vidEncoder);
 5135        }
 5136
 5137        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetIntelVaapiFullVidFilt
 5138            EncodingJobInfo state,
 5139            EncodingOptions options,
 5140            string vidDecoder,
 5141            string vidEncoder)
 5142        {
 05143            var inW = state.VideoStream?.Width;
 05144            var inH = state.VideoStream?.Height;
 05145            var reqW = state.BaseRequest.Width;
 05146            var reqH = state.BaseRequest.Height;
 05147            var reqMaxW = state.BaseRequest.MaxWidth;
 05148            var reqMaxH = state.BaseRequest.MaxHeight;
 05149            var threeDFormat = state.MediaSource.Video3DFormat;
 5150
 05151            var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 05152            var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 05153            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 05154            var isSwEncoder = !isVaapiEncoder;
 05155            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 05156            var isVaInVaOut = isVaapiDecoder && isVaapiEncoder;
 5157
 05158            var doVaVppTonemap = isVaapiDecoder && IsIntelVppTonemapAvailable(state, options);
 05159            var doOclTonemap = !doVaVppTonemap && IsHwTonemapAvailable(state, options);
 05160            var doTonemap = doVaVppTonemap || doOclTonemap;
 05161            var doDeintH2645 = IsDeinterlaceAvailable(state);
 5162
 05163            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 05164            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 05165            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 05166            var hasAssSubs = hasSubs
 05167                && (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)
 05168                    || string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));
 05169            var subW = state.SubtitleStream?.Width;
 05170            var subH = state.SubtitleStream?.Height;
 5171
 05172            var rotation = state.VideoStream?.Rotation ?? 0;
 05173            var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);
 05174            var doVaVppTranspose = !string.IsNullOrEmpty(transposeDir);
 05175            var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder || (isVaapiDecoder && doVaVppTranspose));
 05176            var swpInW = swapWAndH ? inH : inW;
 05177            var swpInH = swapWAndH ? inW : inH;
 5178
 5179            /* Make main filters for video stream */
 05180            var mainFilters = new List<string>();
 5181
 05182            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doTonemap));
 5183
 05184            if (isSwDecoder)
 5185            {
 5186                // INPUT sw surface(memory)
 5187                // sw deint
 05188                if (doDeintH2645)
 5189                {
 05190                    var swDeintFilter = GetSwDeinterlaceFilter(state, options);
 05191                    mainFilters.Add(swDeintFilter);
 5192                }
 5193
 05194                var outFormat = doOclTonemap ? "yuv420p10le" : "nv12";
 05195                var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req
 05196                if (isMjpegEncoder && !doOclTonemap)
 5197                {
 5198                    // sw decoder + hw mjpeg encoder
 05199                    swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r
 5200                }
 5201
 5202                // sw scale
 05203                mainFilters.Add(swScaleFilter);
 05204                mainFilters.Add($"format={outFormat}");
 5205
 5206                // keep video at memory except ocl tonemap,
 5207                // since the overhead caused by hwupload >>> using sw filter.
 5208                // sw => hw
 05209                if (doOclTonemap)
 5210                {
 05211                    mainFilters.Add("hwupload=derive_device=opencl");
 5212                }
 5213            }
 05214            else if (isVaapiDecoder)
 5215            {
 05216                var isRext = IsVideoStreamHevcRext(state);
 5217
 5218                // INPUT vaapi surface(vram)
 5219                // hw deint
 05220                if (doDeintH2645)
 5221                {
 05222                    var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");
 05223                    mainFilters.Add(deintFilter);
 5224                }
 5225
 5226                // hw transpose
 05227                if (doVaVppTranspose)
 5228                {
 05229                    mainFilters.Add($"transpose_vaapi=dir={transposeDir}");
 5230                }
 5231
 05232                var outFormat = doTonemap ? (isRext ? "p010" : string.Empty) : "nv12";
 05233                var hwScaleFilter = GetHwScaleFilter("scale", "vaapi", outFormat, false, swpInW, swpInH, reqW, reqH, req
 5234
 05235                if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder)
 5236                {
 05237                    hwScaleFilter += doOclTonemap ? string.Empty : ":out_range=pc";
 05238                    hwScaleFilter += ":mode=hq";
 5239                }
 5240
 5241                // allocate extra pool sizes for vaapi vpp
 05242                if (!string.IsNullOrEmpty(hwScaleFilter))
 5243                {
 05244                    hwScaleFilter += ":extra_hw_frames=24";
 5245                }
 5246
 5247                // hw scale
 05248                mainFilters.Add(hwScaleFilter);
 5249            }
 5250
 5251            // vaapi vpp tonemap
 05252            if (doVaVppTonemap && isVaapiDecoder)
 5253            {
 05254                var tonemapFilter = GetHwTonemapFilter(options, "vaapi", "nv12", isMjpegEncoder);
 05255                mainFilters.Add(tonemapFilter);
 5256            }
 5257
 05258            if (doOclTonemap && isVaapiDecoder)
 5259            {
 5260                // map from vaapi to opencl via vaapi-opencl interop(Intel only).
 05261                mainFilters.Add("hwmap=derive_device=opencl:mode=read");
 5262            }
 5263
 5264            // ocl tonemap
 05265            if (doOclTonemap)
 5266            {
 05267                var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);
 05268                mainFilters.Add(tonemapFilter);
 5269            }
 5270
 05271            if (doOclTonemap && isVaInVaOut)
 5272            {
 5273                // OUTPUT vaapi(nv12) surface(vram)
 5274                // reverse-mapping via vaapi-opencl interop.
 05275                mainFilters.Add("hwmap=derive_device=vaapi:mode=write:reverse=1");
 05276                mainFilters.Add("format=vaapi");
 5277            }
 5278
 05279            var memoryOutput = false;
 05280            var isUploadForOclTonemap = isSwDecoder && doOclTonemap;
 05281            var isHwmapNotUsable = isUploadForOclTonemap && isVaapiEncoder;
 05282            if ((isVaapiDecoder && isSwEncoder) || isUploadForOclTonemap)
 5283            {
 05284                memoryOutput = true;
 5285
 5286                // OUTPUT nv12 surface(memory)
 5287                // prefer hwmap to hwdownload on opencl/vaapi.
 05288                mainFilters.Add(isHwmapNotUsable ? "hwdownload" : "hwmap=mode=read");
 05289                mainFilters.Add("format=nv12");
 5290            }
 5291
 5292            // OUTPUT nv12 surface(memory)
 05293            if (isSwDecoder && isVaapiEncoder)
 5294            {
 05295                memoryOutput = true;
 5296            }
 5297
 05298            if (memoryOutput)
 5299            {
 5300                // text subtitles
 05301                if (hasTextSubs)
 5302                {
 05303                    var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);
 05304                    mainFilters.Add(textSubtitlesFilter);
 5305                }
 5306            }
 5307
 05308            if (memoryOutput && isVaapiEncoder)
 5309            {
 05310                if (!hasGraphicalSubs)
 5311                {
 05312                    mainFilters.Add("hwupload_vaapi");
 5313                }
 5314            }
 5315
 5316            /* Make sub and overlay filters for subtitle stream */
 05317            var subFilters = new List<string>();
 05318            var overlayFilters = new List<string>();
 05319            if (isVaInVaOut)
 5320            {
 05321                if (hasSubs)
 5322                {
 05323                    if (hasGraphicalSubs)
 5324                    {
 5325                        // overlay_vaapi can handle overlay scaling, setup a smaller height to reduce transfer overhead
 05326                        var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,
 05327                        subFilters.Add(subPreProcFilters);
 05328                        subFilters.Add("format=bgra");
 5329                    }
 05330                    else if (hasTextSubs)
 5331                    {
 05332                        var framerate = state.VideoStream?.RealFrameRate;
 05333                        var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;
 5334
 05335                        var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, 1080, subFram
 05336                        var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);
 05337                        subFilters.Add(alphaSrcFilter);
 05338                        subFilters.Add("format=bgra");
 05339                        subFilters.Add(subTextSubtitlesFilter);
 5340                    }
 5341
 05342                    subFilters.Add("hwupload=derive_device=vaapi");
 5343
 05344                    var (overlayW, overlayH) = GetFixedOutputSize(swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH);
 05345                    var overlaySize = (overlayW.HasValue && overlayH.HasValue)
 05346                        ? $":w={overlayW.Value}:h={overlayH.Value}"
 05347                        : string.Empty;
 05348                    var overlayVaapiFilter = string.Format(
 05349                        CultureInfo.InvariantCulture,
 05350                        "overlay_vaapi=eof_action=pass:repeatlast=0{0}",
 05351                        overlaySize);
 05352                    overlayFilters.Add(overlayVaapiFilter);
 5353                }
 5354            }
 05355            else if (memoryOutput)
 5356            {
 05357                if (hasGraphicalSubs)
 5358                {
 05359                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 05360                    subFilters.Add(subPreProcFilters);
 05361                    overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");
 5362
 05363                    if (isVaapiEncoder)
 5364                    {
 05365                        overlayFilters.Add("hwupload_vaapi");
 5366                    }
 5367                }
 5368            }
 5369
 05370            return (mainFilters, subFilters, overlayFilters);
 5371        }
 5372
 5373        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAmdVaapiFullVidFilter
 5374            EncodingJobInfo state,
 5375            EncodingOptions options,
 5376            string vidDecoder,
 5377            string vidEncoder)
 5378        {
 05379            var inW = state.VideoStream?.Width;
 05380            var inH = state.VideoStream?.Height;
 05381            var reqW = state.BaseRequest.Width;
 05382            var reqH = state.BaseRequest.Height;
 05383            var reqMaxW = state.BaseRequest.MaxWidth;
 05384            var reqMaxH = state.BaseRequest.MaxHeight;
 05385            var threeDFormat = state.MediaSource.Video3DFormat;
 5386
 05387            var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 05388            var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 05389            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 05390            var isSwEncoder = !isVaapiEncoder;
 05391            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 5392
 05393            var doVkTonemap = IsVulkanHwTonemapAvailable(state, options);
 05394            var doDeintH2645 = IsDeinterlaceAvailable(state);
 5395
 05396            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 05397            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 05398            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 05399            var hasAssSubs = hasSubs
 05400                && (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)
 05401                    || string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));
 5402
 05403            var rotation = state.VideoStream?.Rotation ?? 0;
 05404            var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);
 05405            var doVkTranspose = isVaapiDecoder && !string.IsNullOrEmpty(transposeDir);
 05406            var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder || (isVaapiDecoder && doVkTranspose));
 05407            var swpInW = swapWAndH ? inH : inW;
 05408            var swpInH = swapWAndH ? inW : inH;
 5409
 5410            /* Make main filters for video stream */
 05411            var mainFilters = new List<string>();
 5412
 05413            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doVkTonemap));
 5414
 05415            if (isSwDecoder)
 5416            {
 5417                // INPUT sw surface(memory)
 5418                // sw deint
 05419                if (doDeintH2645)
 5420                {
 05421                    var swDeintFilter = GetSwDeinterlaceFilter(state, options);
 05422                    mainFilters.Add(swDeintFilter);
 5423                }
 5424
 05425                if (doVkTonemap || hasSubs)
 5426                {
 5427                    // sw => hw
 05428                    mainFilters.Add("hwupload=derive_device=vulkan");
 05429                    mainFilters.Add("format=vulkan");
 5430                }
 5431                else
 5432                {
 5433                    // sw scale
 05434                    var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW,
 05435                    mainFilters.Add(swScaleFilter);
 05436                    mainFilters.Add("format=nv12");
 5437                }
 5438            }
 05439            else if (isVaapiDecoder)
 5440            {
 5441                // INPUT vaapi surface(vram)
 05442                if (doVkTranspose || doVkTonemap || hasSubs)
 5443                {
 5444                    // map from vaapi to vulkan/drm via interop (Polaris/gfx8+).
 05445                    if (_mediaEncoder.EncoderVersion >= _minFFmpegAlteredVaVkInterop)
 5446                    {
 05447                        if (doVkTranspose || !_mediaEncoder.IsVaapiDeviceSupportVulkanDrmModifier)
 5448                        {
 5449                            // disable the indirect va-drm-vk mapping since it's no longer reliable.
 05450                            mainFilters.Add("hwmap=derive_device=drm");
 05451                            mainFilters.Add("format=drm_prime");
 05452                            mainFilters.Add("hwmap=derive_device=vulkan");
 05453                            mainFilters.Add("format=vulkan");
 5454
 5455                            // workaround for libplacebo using the imported vulkan frame on gfx8.
 05456                            if (!_mediaEncoder.IsVaapiDeviceSupportVulkanDrmModifier)
 5457                            {
 05458                                mainFilters.Add("scale_vulkan");
 5459                            }
 5460                        }
 05461                        else if (doVkTonemap || hasSubs)
 5462                        {
 5463                            // non ad-hoc libplacebo also accepts drm_prime direct input.
 05464                            mainFilters.Add("hwmap=derive_device=drm");
 05465                            mainFilters.Add("format=drm_prime");
 5466                        }
 5467                    }
 5468                    else // legacy va-vk mapping that works only in jellyfin-ffmpeg6
 5469                    {
 05470                        mainFilters.Add("hwmap=derive_device=vulkan");
 05471                        mainFilters.Add("format=vulkan");
 5472                    }
 5473                }
 5474                else
 5475                {
 5476                    // hw deint
 05477                    if (doDeintH2645)
 5478                    {
 05479                        var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");
 05480                        mainFilters.Add(deintFilter);
 5481                    }
 5482
 5483                    // hw scale
 05484                    var hwScaleFilter = GetHwScaleFilter("scale", "vaapi", "nv12", false, inW, inH, reqW, reqH, reqMaxW,
 5485
 05486                    if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder && !doVkTonemap)
 5487                    {
 05488                        hwScaleFilter += ":out_range=pc:mode=hq";
 5489                    }
 5490
 05491                    mainFilters.Add(hwScaleFilter);
 5492                }
 5493            }
 5494
 5495            // vk transpose
 05496            if (doVkTranspose)
 5497            {
 05498                if (string.Equals(transposeDir, "reversal", StringComparison.OrdinalIgnoreCase))
 5499                {
 05500                    mainFilters.Add("flip_vulkan");
 5501                }
 5502                else
 5503                {
 05504                    mainFilters.Add($"transpose_vulkan=dir={transposeDir}");
 5505                }
 5506            }
 5507
 5508            // vk libplacebo
 05509            if (doVkTonemap || hasSubs)
 5510            {
 05511                var libplaceboFilter = GetLibplaceboFilter(options, "bgra", doVkTonemap, swpInW, swpInH, reqW, reqH, req
 05512                mainFilters.Add(libplaceboFilter);
 05513                mainFilters.Add("format=vulkan");
 5514            }
 5515
 05516            if (doVkTonemap && !hasSubs)
 5517            {
 5518                // OUTPUT vaapi(nv12) surface(vram)
 5519                // map from vulkan/drm to vaapi via interop (Polaris/gfx8+).
 05520                mainFilters.Add("hwmap=derive_device=vaapi");
 05521                mainFilters.Add("format=vaapi");
 5522
 5523                // clear the surf->meta_offset and output nv12
 05524                var hwCscFilter = "scale_vaapi=format=nv12";
 5525
 05526                if (!isMjpegEncoder && options.TonemappingRange != TonemappingRange.pc)
 5527                {
 05528                    hwCscFilter += ":out_range=tv";
 5529                }
 5530
 05531                mainFilters.Add(hwCscFilter);
 5532
 5533                // hw deint
 05534                if (doDeintH2645)
 5535                {
 05536                    var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");
 05537                    mainFilters.Add(deintFilter);
 5538                }
 5539            }
 5540
 05541            if (!hasSubs)
 5542            {
 5543                // OUTPUT nv12 surface(memory)
 05544                if (isSwEncoder && (doVkTonemap || isVaapiDecoder))
 5545                {
 05546                    mainFilters.Add("hwdownload");
 05547                    mainFilters.Add("format=nv12");
 5548                }
 5549
 05550                if (isSwDecoder && isVaapiEncoder && !doVkTonemap)
 5551                {
 05552                    mainFilters.Add("hwupload_vaapi");
 5553                }
 5554            }
 5555
 5556            /* Make sub and overlay filters for subtitle stream */
 05557            var subFilters = new List<string>();
 05558            var overlayFilters = new List<string>();
 05559            if (hasSubs)
 5560            {
 05561                if (hasGraphicalSubs)
 5562                {
 05563                    var subW = state.SubtitleStream?.Width;
 05564                    var subH = state.SubtitleStream?.Height;
 05565                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 05566                    subFilters.Add(subPreProcFilters);
 05567                    subFilters.Add("format=bgra");
 5568                }
 05569                else if (hasTextSubs)
 5570                {
 05571                    var framerate = state.VideoStream?.RealFrameRate;
 05572                    var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;
 5573
 05574                    var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH, subFrame
 05575                    var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);
 05576                    subFilters.Add(alphaSrcFilter);
 05577                    subFilters.Add("format=bgra");
 05578                    subFilters.Add(subTextSubtitlesFilter);
 5579                }
 5580
 05581                subFilters.Add("hwupload=derive_device=vulkan");
 05582                subFilters.Add("format=vulkan");
 5583
 05584                overlayFilters.Add("overlay_vulkan=eof_action=pass:repeatlast=0");
 5585
 05586                if (isSwEncoder)
 5587                {
 5588                    // OUTPUT nv12 surface(memory)
 05589                    overlayFilters.Add("scale_vulkan=format=nv12");
 05590                    overlayFilters.Add("hwdownload");
 05591                    overlayFilters.Add("format=nv12");
 5592                }
 05593                else if (isVaapiEncoder)
 5594                {
 5595                    // OUTPUT vaapi(nv12) surface(vram)
 5596                    // map from vulkan/drm to vaapi via interop (Polaris/gfx8+).
 05597                    overlayFilters.Add("hwmap=derive_device=vaapi");
 05598                    overlayFilters.Add("format=vaapi");
 5599
 5600                    // clear the surf->meta_offset and output nv12
 05601                    var hwCscFilter = "scale_vaapi=format=nv12";
 5602
 05603                    if (!doVkTonemap || (doVkTonemap && options.TonemappingRange != TonemappingRange.pc))
 5604                    {
 05605                        hwCscFilter += ":out_range=tv";
 5606                    }
 5607
 05608                    overlayFilters.Add(hwCscFilter);
 5609
 5610                    // hw deint
 05611                    if (doDeintH2645)
 5612                    {
 05613                        var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");
 05614                        overlayFilters.Add(deintFilter);
 5615                    }
 5616                }
 5617            }
 5618
 05619            return (mainFilters, subFilters, overlayFilters);
 5620        }
 5621
 5622        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetVaapiLimitedVidFilter
 5623            EncodingJobInfo state,
 5624            EncodingOptions options,
 5625            string vidDecoder,
 5626            string vidEncoder)
 5627        {
 05628            var inW = state.VideoStream?.Width;
 05629            var inH = state.VideoStream?.Height;
 05630            var reqW = state.BaseRequest.Width;
 05631            var reqH = state.BaseRequest.Height;
 05632            var reqMaxW = state.BaseRequest.MaxWidth;
 05633            var reqMaxH = state.BaseRequest.MaxHeight;
 05634            var threeDFormat = state.MediaSource.Video3DFormat;
 5635
 05636            var isVaapiDecoder = vidDecoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 05637            var isVaapiEncoder = vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase);
 05638            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 05639            var isSwEncoder = !isVaapiEncoder;
 05640            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 05641            var isVaInVaOut = isVaapiDecoder && isVaapiEncoder;
 05642            var isi965Driver = _mediaEncoder.IsVaapiDeviceInteli965;
 05643            var isAmdDriver = _mediaEncoder.IsVaapiDeviceAmd;
 5644
 05645            var doDeintH2645 = IsDeinterlaceAvailable(state);
 05646            var doOclTonemap = IsHwTonemapAvailable(state, options);
 5647
 05648            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 05649            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 05650            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 5651
 05652            var rotation = state.VideoStream?.Rotation ?? 0;
 05653            var swapWAndH = Math.Abs(rotation) == 90 && isSwDecoder;
 05654            var swpInW = swapWAndH ? inH : inW;
 05655            var swpInH = swapWAndH ? inW : inH;
 5656
 5657            /* Make main filters for video stream */
 05658            var mainFilters = new List<string>();
 5659
 05660            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doOclTonemap));
 5661
 05662            var outFormat = string.Empty;
 05663            if (isSwDecoder)
 5664            {
 5665                // INPUT sw surface(memory)
 5666                // sw deint
 05667                if (doDeintH2645)
 5668                {
 05669                    var swDeintFilter = GetSwDeinterlaceFilter(state, options);
 05670                    mainFilters.Add(swDeintFilter);
 5671                }
 5672
 05673                outFormat = doOclTonemap ? "yuv420p10le" : "nv12";
 05674                var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req
 05675                if (isMjpegEncoder && !doOclTonemap)
 5676                {
 5677                    // sw decoder + hw mjpeg encoder
 05678                    swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r
 5679                }
 5680
 5681                // sw scale
 05682                mainFilters.Add(swScaleFilter);
 05683                mainFilters.Add("format=" + outFormat);
 5684
 5685                // keep video at memory except ocl tonemap,
 5686                // since the overhead caused by hwupload >>> using sw filter.
 5687                // sw => hw
 05688                if (doOclTonemap)
 5689                {
 05690                    mainFilters.Add("hwupload=derive_device=opencl");
 5691                }
 5692            }
 05693            else if (isVaapiDecoder)
 5694            {
 5695                // INPUT vaapi surface(vram)
 5696                // hw deint
 05697                if (doDeintH2645)
 5698                {
 05699                    var deintFilter = GetHwDeinterlaceFilter(state, options, "vaapi");
 05700                    mainFilters.Add(deintFilter);
 5701                }
 5702
 05703                outFormat = doOclTonemap ? string.Empty : "nv12";
 05704                var hwScaleFilter = GetHwScaleFilter("scale", "vaapi", outFormat, false, inW, inH, reqW, reqH, reqMaxW, 
 5705
 05706                if (!string.IsNullOrEmpty(hwScaleFilter) && isMjpegEncoder)
 5707                {
 05708                    hwScaleFilter += doOclTonemap ? string.Empty : ":out_range=pc";
 05709                    hwScaleFilter += ":mode=hq";
 5710                }
 5711
 5712                // allocate extra pool sizes for vaapi vpp
 05713                if (!string.IsNullOrEmpty(hwScaleFilter))
 5714                {
 05715                    hwScaleFilter += ":extra_hw_frames=24";
 5716                }
 5717
 5718                // hw scale
 05719                mainFilters.Add(hwScaleFilter);
 5720            }
 5721
 05722            if (doOclTonemap && isVaapiDecoder)
 5723            {
 05724                if (isi965Driver)
 5725                {
 5726                    // map from vaapi to opencl via vaapi-opencl interop(Intel only).
 05727                    mainFilters.Add("hwmap=derive_device=opencl");
 5728                }
 5729                else
 5730                {
 05731                    mainFilters.Add("hwdownload");
 05732                    mainFilters.Add("format=p010le");
 05733                    mainFilters.Add("hwupload=derive_device=opencl");
 5734                }
 5735            }
 5736
 5737            // ocl tonemap
 05738            if (doOclTonemap)
 5739            {
 05740                var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);
 05741                mainFilters.Add(tonemapFilter);
 5742            }
 5743
 05744            if (doOclTonemap && isVaInVaOut)
 5745            {
 05746                if (isi965Driver)
 5747                {
 5748                    // OUTPUT vaapi(nv12) surface(vram)
 5749                    // reverse-mapping via vaapi-opencl interop.
 05750                    mainFilters.Add("hwmap=derive_device=vaapi:reverse=1");
 05751                    mainFilters.Add("format=vaapi");
 5752                }
 5753            }
 5754
 05755            var memoryOutput = false;
 05756            var isUploadForOclTonemap = doOclTonemap && (isSwDecoder || (isVaapiDecoder && !isi965Driver));
 05757            var isHwmapNotUsable = hasGraphicalSubs || isUploadForOclTonemap;
 05758            var isHwmapForSubs = hasSubs && isVaapiDecoder;
 05759            var isHwUnmapForTextSubs = hasTextSubs && isVaInVaOut && !isUploadForOclTonemap;
 05760            if ((isVaapiDecoder && isSwEncoder) || isUploadForOclTonemap || isHwmapForSubs)
 5761            {
 05762                memoryOutput = true;
 5763
 5764                // OUTPUT nv12 surface(memory)
 5765                // prefer hwmap to hwdownload on opencl/vaapi.
 05766                mainFilters.Add(isHwmapNotUsable ? "hwdownload" : "hwmap");
 05767                mainFilters.Add("format=nv12");
 5768            }
 5769
 5770            // OUTPUT nv12 surface(memory)
 05771            if (isSwDecoder && isVaapiEncoder)
 5772            {
 05773                memoryOutput = true;
 5774            }
 5775
 05776            if (memoryOutput)
 5777            {
 5778                // text subtitles
 05779                if (hasTextSubs)
 5780                {
 05781                    var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);
 05782                    mainFilters.Add(textSubtitlesFilter);
 5783                }
 5784            }
 5785
 05786            if (isHwUnmapForTextSubs)
 5787            {
 05788                mainFilters.Add("hwmap");
 05789                mainFilters.Add("format=vaapi");
 5790            }
 05791            else if (memoryOutput && isVaapiEncoder)
 5792            {
 05793                if (!hasGraphicalSubs)
 5794                {
 05795                    mainFilters.Add("hwupload_vaapi");
 5796                }
 5797            }
 5798
 5799            /* Make sub and overlay filters for subtitle stream */
 05800            var subFilters = new List<string>();
 05801            var overlayFilters = new List<string>();
 05802            if (memoryOutput)
 5803            {
 05804                if (hasGraphicalSubs)
 5805                {
 05806                    var subW = state.SubtitleStream?.Width;
 05807                    var subH = state.SubtitleStream?.Height;
 05808                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 05809                    subFilters.Add(subPreProcFilters);
 05810                    overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");
 5811
 05812                    if (isVaapiEncoder)
 5813                    {
 05814                        overlayFilters.Add("hwupload_vaapi");
 5815                    }
 5816                }
 5817            }
 5818
 05819            return (mainFilters, subFilters, overlayFilters);
 5820        }
 5821
 5822        /// <summary>
 5823        /// Gets the parameter of Apple VideoToolBox filter chain.
 5824        /// </summary>
 5825        /// <param name="state">Encoding state.</param>
 5826        /// <param name="options">Encoding options.</param>
 5827        /// <param name="vidEncoder">Video encoder to use.</param>
 5828        /// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>
 5829        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAppleVidFilterChain(
 5830            EncodingJobInfo state,
 5831            EncodingOptions options,
 5832            string vidEncoder)
 5833        {
 05834            if (options.HardwareAccelerationType != HardwareAccelerationType.videotoolbox)
 5835            {
 05836                return (null, null, null);
 5837            }
 5838
 5839            // ReSharper disable once InconsistentNaming
 05840            var isMacOS = OperatingSystem.IsMacOS();
 05841            var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 05842            var isVtDecoder = vidDecoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);
 05843            var isVtEncoder = vidEncoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);
 05844            var isVtFullSupported = isMacOS && IsVideoToolboxFullSupported();
 5845
 5846            // legacy videotoolbox pipeline (disable hw filters)
 05847            if (!(isVtEncoder || isVtDecoder)
 05848                || !isVtFullSupported
 05849                || !_mediaEncoder.SupportsFilter("alphasrc"))
 5850            {
 05851                return GetSwVidFilterChain(state, options, vidEncoder);
 5852            }
 5853
 5854            // preferred videotoolbox + metal filters pipeline
 05855            return GetAppleVidFiltersPreferred(state, options, vidDecoder, vidEncoder);
 5856        }
 5857
 5858        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetAppleVidFiltersPrefer
 5859            EncodingJobInfo state,
 5860            EncodingOptions options,
 5861            string vidDecoder,
 5862            string vidEncoder)
 5863        {
 05864            var isVtEncoder = vidEncoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);
 05865            var isVtDecoder = vidDecoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase);
 05866            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 5867
 05868            var inW = state.VideoStream?.Width;
 05869            var inH = state.VideoStream?.Height;
 05870            var reqW = state.BaseRequest.Width;
 05871            var reqH = state.BaseRequest.Height;
 05872            var reqMaxW = state.BaseRequest.MaxWidth;
 05873            var reqMaxH = state.BaseRequest.MaxHeight;
 05874            var threeDFormat = state.MediaSource.Video3DFormat;
 5875
 05876            var doDeintH2645 = IsDeinterlaceAvailable(state);
 05877            var doVtTonemap = IsVideoToolboxTonemapAvailable(state, options);
 05878            var doMetalTonemap = !doVtTonemap && IsHwTonemapAvailable(state, options);
 05879            var usingHwSurface = isVtDecoder && (_mediaEncoder.EncoderVersion >= _minFFmpegWorkingVtHwSurface);
 5880
 05881            var rotation = state.VideoStream?.Rotation ?? 0;
 05882            var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);
 05883            var doVtTranspose = !string.IsNullOrEmpty(transposeDir) && _mediaEncoder.SupportsFilter("transpose_vt");
 05884            var swapWAndH = Math.Abs(rotation) == 90 && doVtTranspose;
 05885            var swpInW = swapWAndH ? inH : inW;
 05886            var swpInH = swapWAndH ? inW : inH;
 5887
 05888            var scaleFormat = string.Empty;
 5889            // Use P010 for Metal tone mapping, otherwise force an 8bit output.
 05890            if (!string.Equals(state.VideoStream.PixelFormat, "yuv420p", StringComparison.OrdinalIgnoreCase))
 5891            {
 05892                if (doMetalTonemap)
 5893                {
 05894                    if (!string.Equals(state.VideoStream.PixelFormat, "yuv420p10le", StringComparison.OrdinalIgnoreCase)
 5895                    {
 05896                        scaleFormat = "p010le";
 5897                    }
 5898                }
 5899                else
 5900                {
 05901                    scaleFormat = "nv12";
 5902                }
 5903            }
 5904
 05905            var hwScaleFilter = GetHwScaleFilter("scale", "vt", scaleFormat, false, swpInW, swpInH, reqW, reqH, reqMaxW,
 5906
 05907            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 05908            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 05909            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 05910            var hasAssSubs = hasSubs
 05911                && (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)
 05912                    || string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));
 5913
 5914            /* Make main filters for video stream */
 05915            var mainFilters = new List<string>();
 5916
 5917            // hw deint
 05918            if (doDeintH2645)
 5919            {
 05920                var deintFilter = GetHwDeinterlaceFilter(state, options, "videotoolbox");
 05921                mainFilters.Add(deintFilter);
 5922            }
 5923
 5924            // hw transpose
 05925            if (doVtTranspose)
 5926            {
 05927                mainFilters.Add($"transpose_vt=dir={transposeDir}");
 5928            }
 5929
 05930            if (doVtTonemap)
 5931            {
 5932                const string VtTonemapArgs = "color_matrix=bt709:color_primaries=bt709:color_transfer=bt709";
 5933
 5934                // scale_vt can handle scaling & tonemapping in one shot, just like vpp_qsv.
 05935                hwScaleFilter = string.IsNullOrEmpty(hwScaleFilter)
 05936                    ? "scale_vt=" + VtTonemapArgs
 05937                    : hwScaleFilter + ":" + VtTonemapArgs;
 5938            }
 5939
 5940            // hw scale & vt tonemap
 05941            mainFilters.Add(hwScaleFilter);
 5942
 5943            // Metal tonemap
 05944            if (doMetalTonemap)
 5945            {
 05946                var tonemapFilter = GetHwTonemapFilter(options, "videotoolbox", "nv12", isMjpegEncoder);
 05947                mainFilters.Add(tonemapFilter);
 5948            }
 5949
 5950            /* Make sub and overlay filters for subtitle stream */
 05951            var subFilters = new List<string>();
 05952            var overlayFilters = new List<string>();
 5953
 05954            if (hasSubs)
 5955            {
 05956                if (hasGraphicalSubs)
 5957                {
 05958                    var subW = state.SubtitleStream?.Width;
 05959                    var subH = state.SubtitleStream?.Height;
 05960                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 05961                    subFilters.Add(subPreProcFilters);
 05962                    subFilters.Add("format=bgra");
 5963                }
 05964                else if (hasTextSubs)
 5965                {
 05966                    var framerate = state.VideoStream?.RealFrameRate;
 05967                    var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;
 5968
 05969                    var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH, subFrame
 05970                    var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);
 05971                    subFilters.Add(alphaSrcFilter);
 05972                    subFilters.Add("format=bgra");
 05973                    subFilters.Add(subTextSubtitlesFilter);
 5974                }
 5975
 05976                subFilters.Add("hwupload");
 05977                overlayFilters.Add("overlay_videotoolbox=eof_action=pass:repeatlast=0");
 5978            }
 5979
 05980            if (usingHwSurface)
 5981            {
 05982                if (!isVtEncoder)
 5983                {
 05984                    mainFilters.Add("hwdownload");
 05985                    mainFilters.Add("format=nv12");
 5986                }
 5987
 05988                return (mainFilters, subFilters, overlayFilters);
 5989            }
 5990
 5991            // For old jellyfin-ffmpeg that has broken hwsurface, add a hwupload
 05992            var needFiltering = mainFilters.Any(f => !string.IsNullOrEmpty(f)) ||
 05993                                subFilters.Any(f => !string.IsNullOrEmpty(f)) ||
 05994                                overlayFilters.Any(f => !string.IsNullOrEmpty(f));
 05995            if (needFiltering)
 5996            {
 5997                // INPUT videotoolbox/memory surface(vram/uma)
 5998                // this will pass-through automatically if in/out format matches.
 05999                mainFilters.Insert(0, "hwupload");
 06000                mainFilters.Insert(0, "format=nv12|p010le|videotoolbox_vld");
 6001
 06002                if (!isVtEncoder)
 6003                {
 06004                    mainFilters.Add("hwdownload");
 06005                    mainFilters.Add("format=nv12");
 6006                }
 6007            }
 6008
 06009            return (mainFilters, subFilters, overlayFilters);
 6010        }
 6011
 6012        /// <summary>
 6013        /// Gets the parameter of Rockchip RKMPP/RKRGA filter chain.
 6014        /// </summary>
 6015        /// <param name="state">Encoding state.</param>
 6016        /// <param name="options">Encoding options.</param>
 6017        /// <param name="vidEncoder">Video encoder to use.</param>
 6018        /// <returns>The tuple contains three lists: main, sub and overlay filters.</returns>
 6019        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetRkmppVidFilterChain(
 6020            EncodingJobInfo state,
 6021            EncodingOptions options,
 6022            string vidEncoder)
 6023        {
 06024            if (options.HardwareAccelerationType != HardwareAccelerationType.rkmpp)
 6025            {
 06026                return (null, null, null);
 6027            }
 6028
 06029            var isLinux = OperatingSystem.IsLinux();
 06030            var vidDecoder = GetHardwareVideoDecoder(state, options) ?? string.Empty;
 06031            var isSwDecoder = string.IsNullOrEmpty(vidDecoder);
 06032            var isSwEncoder = !vidEncoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);
 06033            var isRkmppOclSupported = isLinux && IsRkmppFullSupported() && IsOpenclFullSupported();
 6034
 06035            if ((isSwDecoder && isSwEncoder)
 06036                || !isRkmppOclSupported
 06037                || !_mediaEncoder.SupportsFilter("alphasrc"))
 6038            {
 06039                return GetSwVidFilterChain(state, options, vidEncoder);
 6040            }
 6041
 6042            // preferred rkmpp + rkrga + opencl filters pipeline
 06043            if (isRkmppOclSupported)
 6044            {
 06045                return GetRkmppVidFiltersPrefered(state, options, vidDecoder, vidEncoder);
 6046            }
 6047
 06048            return (null, null, null);
 6049        }
 6050
 6051        public (List<string> MainFilters, List<string> SubFilters, List<string> OverlayFilters) GetRkmppVidFiltersPrefer
 6052            EncodingJobInfo state,
 6053            EncodingOptions options,
 6054            string vidDecoder,
 6055            string vidEncoder)
 6056        {
 06057            var inW = state.VideoStream?.Width;
 06058            var inH = state.VideoStream?.Height;
 06059            var reqW = state.BaseRequest.Width;
 06060            var reqH = state.BaseRequest.Height;
 06061            var reqMaxW = state.BaseRequest.MaxWidth;
 06062            var reqMaxH = state.BaseRequest.MaxHeight;
 06063            var threeDFormat = state.MediaSource.Video3DFormat;
 6064
 06065            var isRkmppDecoder = vidDecoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);
 06066            var isRkmppEncoder = vidEncoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase);
 06067            var isSwDecoder = !isRkmppDecoder;
 06068            var isSwEncoder = !isRkmppEncoder;
 06069            var isMjpegEncoder = vidEncoder.Contains("mjpeg", StringComparison.OrdinalIgnoreCase);
 06070            var isDrmInDrmOut = isRkmppDecoder && isRkmppEncoder;
 06071            var isEncoderSupportAfbc = isRkmppEncoder
 06072                && (vidEncoder.Contains("h264", StringComparison.OrdinalIgnoreCase)
 06073                    || vidEncoder.Contains("hevc", StringComparison.OrdinalIgnoreCase));
 6074
 06075            var doDeintH2645 = IsDeinterlaceAvailable(state);
 06076            var doOclTonemap = IsHwTonemapAvailable(state, options);
 6077
 06078            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 06079            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 06080            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 06081            var hasAssSubs = hasSubs
 06082                && (string.Equals(state.SubtitleStream.Codec, "ass", StringComparison.OrdinalIgnoreCase)
 06083                    || string.Equals(state.SubtitleStream.Codec, "ssa", StringComparison.OrdinalIgnoreCase));
 06084            var subW = state.SubtitleStream?.Width;
 06085            var subH = state.SubtitleStream?.Height;
 6086
 06087            var rotation = state.VideoStream?.Rotation ?? 0;
 06088            var transposeDir = rotation == 0 ? string.Empty : GetVideoTransposeDirection(state);
 06089            var doRkVppTranspose = !string.IsNullOrEmpty(transposeDir);
 06090            var swapWAndH = Math.Abs(rotation) == 90 && (isSwDecoder || (isRkmppDecoder && doRkVppTranspose));
 06091            var swpInW = swapWAndH ? inH : inW;
 06092            var swpInH = swapWAndH ? inW : inH;
 6093
 6094            /* Make main filters for video stream */
 06095            var mainFilters = new List<string>();
 6096
 06097            mainFilters.Add(GetOverwriteColorPropertiesParam(state, doOclTonemap));
 6098
 06099            if (isSwDecoder)
 6100            {
 6101                // INPUT sw surface(memory)
 6102                // sw deint
 06103                if (doDeintH2645)
 6104                {
 06105                    var swDeintFilter = GetSwDeinterlaceFilter(state, options);
 06106                    mainFilters.Add(swDeintFilter);
 6107                }
 6108
 06109                var outFormat = doOclTonemap ? "yuv420p10le" : (hasGraphicalSubs ? "yuv420p" : "nv12");
 06110                var swScaleFilter = GetSwScaleFilter(state, options, vidEncoder, swpInW, swpInH, threeDFormat, reqW, req
 06111                if (isMjpegEncoder && !doOclTonemap)
 6112                {
 6113                    // sw decoder + hw mjpeg encoder
 06114                    swScaleFilter = string.IsNullOrEmpty(swScaleFilter) ? "scale=out_range=pc" : $"{swScaleFilter}:out_r
 6115                }
 6116
 06117                if (!string.IsNullOrEmpty(swScaleFilter))
 6118                {
 06119                    swScaleFilter += ":flags=fast_bilinear";
 6120                }
 6121
 6122                // sw scale
 06123                mainFilters.Add(swScaleFilter);
 06124                mainFilters.Add($"format={outFormat}");
 6125
 6126                // keep video at memory except ocl tonemap,
 6127                // since the overhead caused by hwupload >>> using sw filter.
 6128                // sw => hw
 06129                if (doOclTonemap)
 6130                {
 06131                    mainFilters.Add("hwupload=derive_device=opencl");
 6132                }
 6133            }
 06134            else if (isRkmppDecoder)
 6135            {
 6136                // INPUT rkmpp/drm surface(gem/dma-heap)
 6137
 06138                var isFullAfbcPipeline = isEncoderSupportAfbc && isDrmInDrmOut && !doOclTonemap;
 06139                var swapOutputWandH = doRkVppTranspose && swapWAndH;
 06140                var outFormat = doOclTonemap ? "p010" : "nv12";
 06141                var hwScaleFilter = GetHwScaleFilter("vpp", "rkrga", outFormat, swapOutputWandH, swpInW, swpInH, reqW, r
 06142                var doScaling = !string.IsNullOrEmpty(GetHwScaleFilter("vpp", "rkrga", string.Empty, swapOutputWandH, sw
 6143
 06144                if (!hasSubs
 06145                     || doRkVppTranspose
 06146                     || !isFullAfbcPipeline
 06147                     || doScaling)
 6148                {
 06149                    var isScaleRatioSupported = IsScaleRatioSupported(inW, inH, reqW, reqH, reqMaxW, reqMaxH, 8.0f);
 6150
 6151                    // RGA3 hardware only support (1/8 ~ 8) scaling in each blit operation,
 6152                    // but in Trickplay there's a case: (3840/320 == 12), enable 2pass for it
 06153                    if (doScaling && !isScaleRatioSupported)
 6154                    {
 6155                        // Vendor provided BSP kernel has an RGA driver bug that causes the output to be corrupted for P
 6156                        // Use NV15 instead of P010 to avoid the issue.
 6157                        // SDR inputs are using BGRA formats already which is not affected.
 06158                        var intermediateFormat = doOclTonemap ? "nv15" : (isMjpegEncoder ? "bgra" : outFormat);
 06159                        var hwScaleFilterFirstPass = $"scale_rkrga=w=iw/7.9:h=ih/7.9:format={intermediateFormat}:force_o
 06160                        mainFilters.Add(hwScaleFilterFirstPass);
 6161                    }
 6162
 6163                    // The RKMPP MJPEG encoder on some newer chip models no longer supports RGB input.
 6164                    // Use 2pass here to enable RGA output of full-range YUV in the 2nd pass.
 06165                    if (isMjpegEncoder && !doOclTonemap && ((doScaling && isScaleRatioSupported) || !doScaling))
 6166                    {
 06167                        var hwScaleFilterFirstPass = "vpp_rkrga=format=bgra:afbc=1";
 06168                        mainFilters.Add(hwScaleFilterFirstPass);
 6169                    }
 6170
 06171                    if (!string.IsNullOrEmpty(hwScaleFilter) && doRkVppTranspose)
 6172                    {
 06173                        hwScaleFilter += $":transpose={transposeDir}";
 6174                    }
 6175
 6176                    // try enabling AFBC to save DDR bandwidth
 06177                    if (!string.IsNullOrEmpty(hwScaleFilter) && isFullAfbcPipeline)
 6178                    {
 06179                        hwScaleFilter += ":afbc=1";
 6180                    }
 6181
 6182                    // hw transpose & scale
 06183                    mainFilters.Add(hwScaleFilter);
 6184                }
 6185            }
 6186
 06187            if (doOclTonemap && isRkmppDecoder)
 6188            {
 6189                // map from rkmpp/drm to opencl via drm-opencl interop.
 06190                mainFilters.Add("hwmap=derive_device=opencl");
 6191            }
 6192
 6193            // ocl tonemap
 06194            if (doOclTonemap)
 6195            {
 06196                var tonemapFilter = GetHwTonemapFilter(options, "opencl", "nv12", isMjpegEncoder);
 06197                mainFilters.Add(tonemapFilter);
 6198            }
 6199
 06200            var memoryOutput = false;
 06201            var isUploadForOclTonemap = isSwDecoder && doOclTonemap;
 06202            if ((isRkmppDecoder && isSwEncoder) || isUploadForOclTonemap)
 6203            {
 06204                memoryOutput = true;
 6205
 6206                // OUTPUT nv12 surface(memory)
 06207                mainFilters.Add("hwdownload");
 06208                mainFilters.Add("format=nv12");
 6209            }
 6210
 6211            // OUTPUT nv12 surface(memory)
 06212            if (isSwDecoder && isRkmppEncoder)
 6213            {
 06214                memoryOutput = true;
 6215            }
 6216
 06217            if (memoryOutput)
 6218            {
 6219                // text subtitles
 06220                if (hasTextSubs)
 6221                {
 06222                    var textSubtitlesFilter = GetTextSubtitlesFilter(state, false, false);
 06223                    mainFilters.Add(textSubtitlesFilter);
 6224                }
 6225            }
 6226
 06227            if (isDrmInDrmOut)
 6228            {
 06229                if (doOclTonemap)
 6230                {
 6231                    // OUTPUT drm(nv12) surface(gem/dma-heap)
 6232                    // reverse-mapping via drm-opencl interop.
 06233                    mainFilters.Add("hwmap=derive_device=rkmpp:reverse=1");
 06234                    mainFilters.Add("format=drm_prime");
 6235                }
 6236            }
 6237
 6238            /* Make sub and overlay filters for subtitle stream */
 06239            var subFilters = new List<string>();
 06240            var overlayFilters = new List<string>();
 06241            if (isDrmInDrmOut)
 6242            {
 06243                if (hasSubs)
 6244                {
 06245                    var subMaxH = 1080;
 06246                    if (hasGraphicalSubs)
 6247                    {
 06248                        var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH,
 06249                        subFilters.Add(subPreProcFilters);
 06250                        subFilters.Add("format=bgra");
 6251                    }
 06252                    else if (hasTextSubs)
 6253                    {
 06254                        var framerate = state.VideoStream?.RealFrameRate;
 06255                        var subFramerate = hasAssSubs ? Math.Min(framerate ?? 25, 60) : 10;
 6256
 6257                        // alphasrc=s=1280x720:r=10:start=0,format=bgra,subtitles,hwupload
 06258                        var alphaSrcFilter = GetAlphaSrcFilter(state, swpInW, swpInH, reqW, reqH, reqMaxW, subMaxH, subF
 06259                        var subTextSubtitlesFilter = GetTextSubtitlesFilter(state, true, true);
 06260                        subFilters.Add(alphaSrcFilter);
 06261                        subFilters.Add("format=bgra");
 06262                        subFilters.Add(subTextSubtitlesFilter);
 6263                    }
 6264
 06265                    subFilters.Add("hwupload=derive_device=rkmpp");
 6266
 6267                    // offload 1080p+ subtitles swscale upscaling from CPU to RGA
 06268                    var (overlayW, overlayH) = GetFixedOutputSize(swpInW, swpInH, reqW, reqH, reqMaxW, reqMaxH);
 06269                    if (overlayW.HasValue && overlayH.HasValue && overlayH.Value > subMaxH)
 6270                    {
 06271                        subFilters.Add($"vpp_rkrga=w={overlayW.Value}:h={overlayH.Value}:format=bgra:afbc=1");
 6272                    }
 6273
 6274                    // try enabling AFBC to save DDR bandwidth
 06275                    var hwOverlayFilter = "overlay_rkrga=eof_action=pass:repeatlast=0:format=nv12";
 06276                    if (isEncoderSupportAfbc)
 6277                    {
 06278                        hwOverlayFilter += ":afbc=1";
 6279                    }
 6280
 06281                    overlayFilters.Add(hwOverlayFilter);
 6282                }
 6283            }
 06284            else if (memoryOutput)
 6285            {
 06286                if (hasGraphicalSubs)
 6287                {
 06288                    var subPreProcFilters = GetGraphicalSubPreProcessFilters(swpInW, swpInH, subW, subH, reqW, reqH, req
 06289                    subFilters.Add(subPreProcFilters);
 06290                    overlayFilters.Add("overlay=eof_action=pass:repeatlast=0");
 6291                }
 6292            }
 6293
 06294            return (mainFilters, subFilters, overlayFilters);
 6295        }
 6296
 6297        /// <summary>
 6298        /// Gets the parameter of video processing filters.
 6299        /// </summary>
 6300        /// <param name="state">Encoding state.</param>
 6301        /// <param name="options">Encoding options.</param>
 6302        /// <param name="outputVideoCodec">Video codec to use.</param>
 6303        /// <returns>The video processing filters parameter.</returns>
 6304        public string GetVideoProcessingFilterParam(
 6305            EncodingJobInfo state,
 6306            EncodingOptions options,
 6307            string outputVideoCodec)
 6308        {
 06309            var videoStream = state.VideoStream;
 06310            if (videoStream is null)
 6311            {
 06312                return string.Empty;
 6313            }
 6314
 06315            var hasSubs = state.SubtitleStream is not null && ShouldEncodeSubtitle(state);
 06316            var hasTextSubs = hasSubs && state.SubtitleStream.IsTextSubtitleStream;
 06317            var hasGraphicalSubs = hasSubs && !state.SubtitleStream.IsTextSubtitleStream;
 6318
 6319            List<string> mainFilters;
 6320            List<string> subFilters;
 6321            List<string> overlayFilters;
 6322
 06323            (mainFilters, subFilters, overlayFilters) = options.HardwareAccelerationType switch
 06324            {
 06325                HardwareAccelerationType.vaapi => GetVaapiVidFilterChain(state, options, outputVideoCodec),
 06326                HardwareAccelerationType.amf => GetAmdVidFilterChain(state, options, outputVideoCodec),
 06327                HardwareAccelerationType.qsv => GetIntelVidFilterChain(state, options, outputVideoCodec),
 06328                HardwareAccelerationType.nvenc => GetNvidiaVidFilterChain(state, options, outputVideoCodec),
 06329                HardwareAccelerationType.videotoolbox => GetAppleVidFilterChain(state, options, outputVideoCodec),
 06330                HardwareAccelerationType.rkmpp => GetRkmppVidFilterChain(state, options, outputVideoCodec),
 06331                _ => GetSwVidFilterChain(state, options, outputVideoCodec),
 06332            };
 6333
 06334            mainFilters?.RemoveAll(string.IsNullOrEmpty);
 06335            subFilters?.RemoveAll(string.IsNullOrEmpty);
 06336            overlayFilters?.RemoveAll(string.IsNullOrEmpty);
 6337
 06338            var framerate = GetFramerateParam(state);
 06339            if (mainFilters is not null && framerate.HasValue)
 6340            {
 06341                var doDeintH2645 = IsDeinterlaceAvailable(state);
 06342                var fpsFilter = string.Format(CultureInfo.InvariantCulture, "fps={0}", framerate.Value);
 6343
 6344                // For filter chain containing the deinterlace filter,
 6345                // place the fps filter at the end to preserve temporal info.
 06346                if (doDeintH2645)
 6347                {
 06348                    mainFilters.Add(fpsFilter);
 6349                }
 6350                else
 6351                {
 06352                    mainFilters.Insert(0, fpsFilter);
 6353                }
 6354            }
 6355
 06356            var mainStr = string.Empty;
 06357            if (mainFilters?.Count > 0)
 6358            {
 06359                mainStr = string.Format(
 06360                    CultureInfo.InvariantCulture,
 06361                    "{0}",
 06362                    string.Join(',', mainFilters));
 6363            }
 6364
 06365            if (overlayFilters?.Count == 0)
 6366            {
 6367                // -vf "scale..."
 06368                return string.IsNullOrEmpty(mainStr) ? string.Empty : " -vf \"" + mainStr + "\"";
 6369            }
 6370
 06371            if (overlayFilters?.Count > 0
 06372                && subFilters?.Count > 0
 06373                && state.SubtitleStream is not null)
 6374            {
 6375                // overlay graphical/text subtitles
 06376                var subStr = string.Format(
 06377                        CultureInfo.InvariantCulture,
 06378                        "{0}",
 06379                        string.Join(',', subFilters));
 6380
 06381                var overlayStr = string.Format(
 06382                        CultureInfo.InvariantCulture,
 06383                        "{0}",
 06384                        string.Join(',', overlayFilters));
 6385
 06386                var mapPrefix = Convert.ToInt32(state.SubtitleStream.IsExternal);
 06387                var subtitleStreamIndex = GetSubtitleStreamIndexForFfmpeg(state.MediaSource, state.SubtitleStream);
 06388                var videoStreamIndex = FindIndex(state.MediaSource.MediaStreams, state.VideoStream);
 6389
 06390                if (hasSubs)
 6391                {
 6392                    // -filter_complex "[0:s]scale=s[sub]..."
 06393                    var filterStr = string.IsNullOrEmpty(mainStr)
 06394                        ? " -filter_complex \"[{0}:{1}]{4}[sub];[0:{2}][sub]{5}\""
 06395                        : " -filter_complex \"[{0}:{1}]{4}[sub];[0:{2}]{3}[main];[main][sub]{5}\"";
 6396
 06397                    if (hasTextSubs)
 6398                    {
 06399                        filterStr = string.IsNullOrEmpty(mainStr)
 06400                            ? " -filter_complex \"{4}[sub];[0:{2}][sub]{5}\""
 06401                            : " -filter_complex \"{4}[sub];[0:{2}]{3}[main];[main][sub]{5}\"";
 6402                    }
 6403
 06404                    return string.Format(
 06405                        CultureInfo.InvariantCulture,
 06406                        filterStr,
 06407                        mapPrefix,
 06408                        subtitleStreamIndex,
 06409                        videoStreamIndex,
 06410                        mainStr,
 06411                        subStr,
 06412                        overlayStr);
 6413                }
 6414            }
 6415
 06416            return string.Empty;
 6417        }
 6418
 6419        public string GetOverwriteColorPropertiesParam(EncodingJobInfo state, bool isTonemapAvailable)
 6420        {
 66421            if (isTonemapAvailable)
 6422            {
 26423                return GetInputHdrParam(state.VideoStream?.ColorTransfer);
 6424            }
 6425
 46426            return GetOutputSdrParam(null);
 6427        }
 6428
 6429        public string GetInputHdrParam(string colorTransfer)
 6430        {
 26431            if (string.Equals(colorTransfer, "arib-std-b67", StringComparison.OrdinalIgnoreCase))
 6432            {
 6433                // HLG
 16434                return "setparams=color_primaries=bt2020:color_trc=arib-std-b67:colorspace=bt2020nc";
 6435            }
 6436
 6437            // HDR10
 16438            return "setparams=color_primaries=bt2020:color_trc=smpte2084:colorspace=bt2020nc";
 6439        }
 6440
 6441        public string GetOutputSdrParam(string tonemappingRange)
 6442        {
 6443            // SDR
 46444            if (string.Equals(tonemappingRange, "tv", StringComparison.OrdinalIgnoreCase))
 6445            {
 06446                return "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709:range=tv";
 6447            }
 6448
 46449            if (string.Equals(tonemappingRange, "pc", StringComparison.OrdinalIgnoreCase))
 6450            {
 06451                return "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709:range=pc";
 6452            }
 6453
 46454            return "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709";
 6455        }
 6456
 6457        public static int GetVideoColorBitDepth(EncodingJobInfo state)
 6458        {
 66459            var videoStream = state.VideoStream;
 66460            if (videoStream is not null)
 6461            {
 66462                if (videoStream.BitDepth.HasValue)
 6463                {
 66464                    return videoStream.BitDepth.Value;
 6465                }
 6466
 06467                if (string.Equals(videoStream.PixelFormat, "yuv420p", StringComparison.OrdinalIgnoreCase)
 06468                    || string.Equals(videoStream.PixelFormat, "yuvj420p", StringComparison.OrdinalIgnoreCase)
 06469                    || string.Equals(videoStream.PixelFormat, "yuv422p", StringComparison.OrdinalIgnoreCase)
 06470                    || string.Equals(videoStream.PixelFormat, "yuv444p", StringComparison.OrdinalIgnoreCase))
 6471                {
 06472                    return 8;
 6473                }
 6474
 06475                if (string.Equals(videoStream.PixelFormat, "yuv420p10le", StringComparison.OrdinalIgnoreCase)
 06476                    || string.Equals(videoStream.PixelFormat, "yuv422p10le", StringComparison.OrdinalIgnoreCase)
 06477                    || string.Equals(videoStream.PixelFormat, "yuv444p10le", StringComparison.OrdinalIgnoreCase))
 6478                {
 06479                    return 10;
 6480                }
 6481
 06482                if (string.Equals(videoStream.PixelFormat, "yuv420p12le", StringComparison.OrdinalIgnoreCase)
 06483                    || string.Equals(videoStream.PixelFormat, "yuv422p12le", StringComparison.OrdinalIgnoreCase)
 06484                    || string.Equals(videoStream.PixelFormat, "yuv444p12le", StringComparison.OrdinalIgnoreCase))
 6485                {
 06486                    return 12;
 6487                }
 6488
 06489                return 8;
 6490            }
 6491
 06492            return 0;
 6493        }
 6494
 6495        /// <summary>
 6496        /// Gets the ffmpeg option string for the hardware accelerated video decoder.
 6497        /// </summary>
 6498        /// <param name="state">The encoding job info.</param>
 6499        /// <param name="options">The encoding options.</param>
 6500        /// <returns>The option string or null if none available.</returns>
 6501        protected string GetHardwareVideoDecoder(EncodingJobInfo state, EncodingOptions options)
 6502        {
 246503            var videoStream = state.VideoStream;
 246504            var mediaSource = state.MediaSource;
 246505            if (videoStream is null || mediaSource is null)
 6506            {
 146507                return null;
 6508            }
 6509
 6510            // HWA decoders can handle both video files and video folders.
 106511            var videoType = state.VideoType;
 106512            if (videoType != VideoType.VideoFile
 106513                && videoType != VideoType.Iso
 106514                && videoType != VideoType.Dvd
 106515                && videoType != VideoType.BluRay)
 6516            {
 06517                return null;
 6518            }
 6519
 106520            if (IsCopyCodec(state.OutputVideoCodec))
 6521            {
 66522                return null;
 6523            }
 6524
 46525            var hardwareAccelerationType = options.HardwareAccelerationType;
 6526
 46527            if (!string.IsNullOrEmpty(videoStream.Codec) && hardwareAccelerationType != HardwareAccelerationType.none)
 6528            {
 06529                var bitDepth = GetVideoColorBitDepth(state);
 6530
 6531                // Only HEVC, VP9 and AV1 formats have 10-bit hardware decoder support for most platforms
 06532                if (bitDepth == 10
 06533                    && !(string.Equals(videoStream.Codec, "hevc", StringComparison.OrdinalIgnoreCase)
 06534                         || string.Equals(videoStream.Codec, "h265", StringComparison.OrdinalIgnoreCase)
 06535                         || string.Equals(videoStream.Codec, "vp9", StringComparison.OrdinalIgnoreCase)
 06536                         || string.Equals(videoStream.Codec, "av1", StringComparison.OrdinalIgnoreCase)))
 6537                {
 6538                    // RKMPP has H.264 Hi10P decoder
 06539                    bool hasHardwareHi10P = hardwareAccelerationType == HardwareAccelerationType.rkmpp;
 6540
 6541                    // VideoToolbox on Apple Silicon has H.264 Hi10P mode enabled after macOS 14.6
 06542                    if (hardwareAccelerationType == HardwareAccelerationType.videotoolbox)
 6543                    {
 06544                        var ver = Environment.OSVersion.Version;
 06545                        var arch = RuntimeInformation.OSArchitecture;
 06546                        if (arch.Equals(Architecture.Arm64) && ver >= new Version(14, 6))
 6547                        {
 06548                            hasHardwareHi10P = true;
 6549                        }
 6550                    }
 6551
 06552                    if (!hasHardwareHi10P
 06553                        && string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase))
 6554                    {
 06555                        return null;
 6556                    }
 6557                }
 6558
 6559                // Block unsupported H.264 Hi422P and Hi444PP profiles, which can be encoded with 4:2:0 pixel format
 06560                if (string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase)
 06561                    && ((videoStream.Profile?.Contains("4:2:2", StringComparison.OrdinalIgnoreCase) ?? false)
 06562                        || (videoStream.Profile?.Contains("4:4:4", StringComparison.OrdinalIgnoreCase) ?? false)))
 6563                {
 6564                    // VideoToolbox on Apple Silicon has H.264 Hi444PP and theoretically also has Hi422P
 06565                    if (!(hardwareAccelerationType == HardwareAccelerationType.videotoolbox
 06566                          && RuntimeInformation.OSArchitecture.Equals(Architecture.Arm64)))
 6567                    {
 06568                        return null;
 6569                    }
 6570                }
 6571
 06572                var decoder = hardwareAccelerationType switch
 06573                {
 06574                    HardwareAccelerationType.vaapi => GetVaapiVidDecoder(state, options, videoStream, bitDepth),
 06575                    HardwareAccelerationType.amf => GetAmfVidDecoder(state, options, videoStream, bitDepth),
 06576                    HardwareAccelerationType.qsv => GetQsvHwVidDecoder(state, options, videoStream, bitDepth),
 06577                    HardwareAccelerationType.nvenc => GetNvdecVidDecoder(state, options, videoStream, bitDepth),
 06578                    HardwareAccelerationType.videotoolbox => GetVideotoolboxVidDecoder(state, options, videoStream, bitD
 06579                    HardwareAccelerationType.rkmpp => GetRkmppVidDecoder(state, options, videoStream, bitDepth),
 06580                    _ => string.Empty
 06581                };
 6582
 06583                if (!string.IsNullOrEmpty(decoder))
 6584                {
 06585                    return decoder;
 6586                }
 6587            }
 6588
 6589            // leave blank so ffmpeg will decide
 46590            return null;
 6591        }
 6592
 6593        /// <summary>
 6594        /// Gets a hw decoder name.
 6595        /// </summary>
 6596        /// <param name="options">Encoding options.</param>
 6597        /// <param name="decoderPrefix">Decoder prefix.</param>
 6598        /// <param name="decoderSuffix">Decoder suffix.</param>
 6599        /// <param name="videoCodec">Video codec to use.</param>
 6600        /// <param name="bitDepth">Video color bit depth.</param>
 6601        /// <returns>Hardware decoder name.</returns>
 6602        public string GetHwDecoderName(EncodingOptions options, string decoderPrefix, string decoderSuffix, string video
 6603        {
 06604            if (string.IsNullOrEmpty(decoderPrefix) || string.IsNullOrEmpty(decoderSuffix))
 6605            {
 06606                return null;
 6607            }
 6608
 06609            var decoderName = decoderPrefix + '_' + decoderSuffix;
 6610
 06611            var isCodecAvailable = _mediaEncoder.SupportsDecoder(decoderName) && options.HardwareDecodingCodecs.Contains
 6612
 6613            // VideoToolbox decoders have built-in SW fallback
 06614            if (bitDepth == 10
 06615                && isCodecAvailable
 06616                && (options.HardwareAccelerationType != HardwareAccelerationType.videotoolbox))
 6617            {
 06618                if (string.Equals(videoCodec, "hevc", StringComparison.OrdinalIgnoreCase)
 06619                    && options.HardwareDecodingCodecs.Contains("hevc", StringComparison.OrdinalIgnoreCase)
 06620                    && !options.EnableDecodingColorDepth10Hevc)
 6621                {
 06622                    return null;
 6623                }
 6624
 06625                if (string.Equals(videoCodec, "vp9", StringComparison.OrdinalIgnoreCase)
 06626                    && options.HardwareDecodingCodecs.Contains("vp9", StringComparison.OrdinalIgnoreCase)
 06627                    && !options.EnableDecodingColorDepth10Vp9)
 6628                {
 06629                    return null;
 6630                }
 6631            }
 6632
 06633            if (string.Equals(decoderSuffix, "cuvid", StringComparison.OrdinalIgnoreCase) && options.EnableEnhancedNvdec
 6634            {
 06635                return null;
 6636            }
 6637
 06638            if (string.Equals(decoderSuffix, "qsv", StringComparison.OrdinalIgnoreCase) && options.PreferSystemNativeHwD
 6639            {
 06640                return null;
 6641            }
 6642
 06643            if (string.Equals(decoderSuffix, "rkmpp", StringComparison.OrdinalIgnoreCase))
 6644            {
 06645                return null;
 6646            }
 6647
 06648            return isCodecAvailable ? (" -c:v " + decoderName) : null;
 6649        }
 6650
 6651        /// <summary>
 6652        /// Gets a hwaccel type to use as a hardware decoder depending on the system.
 6653        /// </summary>
 6654        /// <param name="state">Encoding state.</param>
 6655        /// <param name="options">Encoding options.</param>
 6656        /// <param name="videoCodec">Video codec to use.</param>
 6657        /// <param name="bitDepth">Video color bit depth.</param>
 6658        /// <param name="outputHwSurface">Specifies if output hw surface.</param>
 6659        /// <returns>Hardware accelerator type.</returns>
 6660        public string GetHwaccelType(EncodingJobInfo state, EncodingOptions options, string videoCodec, int bitDepth, bo
 6661        {
 06662            var isWindows = OperatingSystem.IsWindows();
 06663            var isLinux = OperatingSystem.IsLinux();
 06664            var isMacOS = OperatingSystem.IsMacOS();
 06665            var isD3d11Supported = isWindows && _mediaEncoder.SupportsHwaccel("d3d11va");
 06666            var isVaapiSupported = isLinux && IsVaapiSupported(state);
 06667            var isCudaSupported = (isLinux || isWindows) && IsCudaFullSupported();
 06668            var isQsvSupported = (isLinux || isWindows) && _mediaEncoder.SupportsHwaccel("qsv");
 06669            var isVideotoolboxSupported = isMacOS && _mediaEncoder.SupportsHwaccel("videotoolbox");
 06670            var isRkmppSupported = isLinux && IsRkmppFullSupported();
 06671            var isCodecAvailable = options.HardwareDecodingCodecs.Contains(videoCodec, StringComparison.OrdinalIgnoreCas
 06672            var hardwareAccelerationType = options.HardwareAccelerationType;
 6673
 06674            var ffmpegVersion = _mediaEncoder.EncoderVersion;
 6675
 6676            // Set the av1 codec explicitly to trigger hw accelerator, otherwise libdav1d will be used.
 06677            var isAv1 = ffmpegVersion < _minFFmpegImplicitHwaccel
 06678                && string.Equals(videoCodec, "av1", StringComparison.OrdinalIgnoreCase);
 6679
 6680            // Allow profile mismatch if decoding H.264 baseline with d3d11va and vaapi hwaccels.
 06681            var profileMismatch = string.Equals(videoCodec, "h264", StringComparison.OrdinalIgnoreCase)
 06682                && string.Equals(state.VideoStream?.Profile, "baseline", StringComparison.OrdinalIgnoreCase);
 6683
 6684            // Disable the extra internal copy in nvdec. We already handle it in filter chain.
 06685            var nvdecNoInternalCopy = ffmpegVersion >= _minFFmpegHwaUnsafeOutput;
 6686
 6687            // Strip the display rotation side data from the transposed fmp4 output stream.
 06688            var stripRotationData = (state.VideoStream?.Rotation ?? 0) != 0
 06689                && ffmpegVersion >= _minFFmpegDisplayRotationOption;
 06690            var stripRotationDataArgs = stripRotationData ? " -display_rotation 0" : string.Empty;
 6691
 6692            // VideoToolbox decoders have built-in SW fallback
 06693            if (isCodecAvailable
 06694                && (options.HardwareAccelerationType != HardwareAccelerationType.videotoolbox))
 6695            {
 06696                if (string.Equals(videoCodec, "hevc", StringComparison.OrdinalIgnoreCase)
 06697                    && options.HardwareDecodingCodecs.Contains("hevc", StringComparison.OrdinalIgnoreCase))
 6698                {
 06699                    if (IsVideoStreamHevcRext(state))
 6700                    {
 06701                        if (bitDepth <= 10 && !options.EnableDecodingColorDepth10HevcRext)
 6702                        {
 06703                            return null;
 6704                        }
 6705
 06706                        if (bitDepth == 12 && !options.EnableDecodingColorDepth12HevcRext)
 6707                        {
 06708                            return null;
 6709                        }
 6710
 06711                        if (hardwareAccelerationType == HardwareAccelerationType.vaapi
 06712                            && !_mediaEncoder.IsVaapiDeviceInteliHD)
 6713                        {
 06714                            return null;
 6715                        }
 6716                    }
 06717                    else if (bitDepth == 10 && !options.EnableDecodingColorDepth10Hevc)
 6718                    {
 06719                        return null;
 6720                    }
 6721                }
 6722
 06723                if (string.Equals(videoCodec, "vp9", StringComparison.OrdinalIgnoreCase)
 06724                    && options.HardwareDecodingCodecs.Contains("vp9", StringComparison.OrdinalIgnoreCase)
 06725                    && bitDepth == 10
 06726                    && !options.EnableDecodingColorDepth10Vp9)
 6727                {
 06728                    return null;
 6729                }
 6730            }
 6731
 6732            // Intel qsv/d3d11va/vaapi
 06733            if (hardwareAccelerationType == HardwareAccelerationType.qsv)
 6734            {
 06735                if (options.PreferSystemNativeHwDecoder)
 6736                {
 06737                    if (isVaapiSupported && isCodecAvailable)
 6738                    {
 06739                        return " -hwaccel vaapi" + (outputHwSurface ? " -hwaccel_output_format vaapi -noautorotate" + st
 06740                            + (profileMismatch ? " -hwaccel_flags +allow_profile_mismatch" : string.Empty) + (isAv1 ? " 
 6741                    }
 6742
 06743                    if (isD3d11Supported && isCodecAvailable)
 6744                    {
 06745                        return " -hwaccel d3d11va" + (outputHwSurface ? " -hwaccel_output_format d3d11 -noautorotate" + 
 06746                            + (profileMismatch ? " -hwaccel_flags +allow_profile_mismatch" : string.Empty) + " -threads 
 6747                    }
 6748                }
 6749                else
 6750                {
 06751                    if (isQsvSupported && isCodecAvailable)
 6752                    {
 06753                        return " -hwaccel qsv" + (outputHwSurface ? " -hwaccel_output_format qsv -noautorotate" + stripR
 6754                    }
 6755                }
 6756            }
 6757
 6758            // Nvidia cuda
 06759            if (hardwareAccelerationType == HardwareAccelerationType.nvenc)
 6760            {
 06761                if (isCudaSupported && isCodecAvailable)
 6762                {
 06763                    if (options.EnableEnhancedNvdecDecoder)
 6764                    {
 6765                        // set -threads 1 to nvdec decoder explicitly since it doesn't implement threading support.
 06766                        return " -hwaccel cuda" + (outputHwSurface ? " -hwaccel_output_format cuda -noautorotate" + stri
 06767                            + (nvdecNoInternalCopy ? " -hwaccel_flags +unsafe_output" : string.Empty) + " -threads 1" + 
 6768                    }
 6769
 6770                    // cuvid decoder doesn't have threading issue.
 06771                    return " -hwaccel cuda" + (outputHwSurface ? " -hwaccel_output_format cuda -noautorotate" + stripRot
 6772                }
 6773            }
 6774
 6775            // Amd d3d11va
 06776            if (hardwareAccelerationType == HardwareAccelerationType.amf)
 6777            {
 06778                if (isD3d11Supported && isCodecAvailable)
 6779                {
 06780                    return " -hwaccel d3d11va" + (outputHwSurface ? " -hwaccel_output_format d3d11 -noautorotate" + stri
 06781                        + (profileMismatch ? " -hwaccel_flags +allow_profile_mismatch" : string.Empty) + " -threads 2" +
 6782                }
 6783            }
 6784
 6785            // Vaapi
 06786            if (hardwareAccelerationType == HardwareAccelerationType.vaapi
 06787                && isVaapiSupported
 06788                && isCodecAvailable)
 6789            {
 06790                return " -hwaccel vaapi" + (outputHwSurface ? " -hwaccel_output_format vaapi -noautorotate" + stripRotat
 06791                    + (profileMismatch ? " -hwaccel_flags +allow_profile_mismatch" : string.Empty) + (isAv1 ? " -c:v av1
 6792            }
 6793
 6794            // Apple videotoolbox
 06795            if (hardwareAccelerationType == HardwareAccelerationType.videotoolbox
 06796                && isVideotoolboxSupported
 06797                && isCodecAvailable)
 6798            {
 06799                return " -hwaccel videotoolbox" + (outputHwSurface ? " -hwaccel_output_format videotoolbox_vld" : string
 6800            }
 6801
 6802            // Rockchip rkmpp
 06803            if (hardwareAccelerationType == HardwareAccelerationType.rkmpp
 06804                && isRkmppSupported
 06805                && isCodecAvailable)
 6806            {
 06807                return " -hwaccel rkmpp" + (outputHwSurface ? " -hwaccel_output_format drm_prime -noautorotate" + stripR
 6808            }
 6809
 06810            return null;
 6811        }
 6812
 6813        public string GetQsvHwVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bi
 6814        {
 06815            var isWindows = OperatingSystem.IsWindows();
 06816            var isLinux = OperatingSystem.IsLinux();
 6817
 06818            if ((!isWindows && !isLinux)
 06819                || options.HardwareAccelerationType != HardwareAccelerationType.qsv)
 6820            {
 06821                return null;
 6822            }
 6823
 06824            var isQsvOclSupported = _mediaEncoder.SupportsHwaccel("qsv") && IsOpenclFullSupported();
 06825            var isIntelDx11OclSupported = isWindows
 06826                && _mediaEncoder.SupportsHwaccel("d3d11va")
 06827                && isQsvOclSupported;
 06828            var isIntelVaapiOclSupported = isLinux
 06829                && IsVaapiSupported(state)
 06830                && isQsvOclSupported;
 06831            var hwSurface = (isIntelDx11OclSupported || isIntelVaapiOclSupported)
 06832                && _mediaEncoder.SupportsFilter("alphasrc");
 6833
 06834            var is8bitSwFormatsQsv = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCas
 06835                                     || string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgnor
 06836            var is8_10bitSwFormatsQsv = is8bitSwFormatsQsv || string.Equals("yuv420p10le", videoStream.PixelFormat, Stri
 06837            var is8_10_12bitSwFormatsQsv = is8_10bitSwFormatsQsv
 06838                || string.Equals("yuv422p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06839                || string.Equals("yuv444p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06840                || string.Equals("yuv422p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06841                || string.Equals("yuv444p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06842                || string.Equals("yuv420p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06843                || string.Equals("yuv422p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06844                || string.Equals("yuv444p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase);
 6845            // TODO: add more 8/10bit and 4:4:4 formats for Qsv after finishing the ffcheck tool
 6846
 06847            if (is8bitSwFormatsQsv)
 6848            {
 06849                if (string.Equals(videoStream.Codec, "avc", StringComparison.OrdinalIgnoreCase)
 06850                    || string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase))
 6851                {
 06852                    return GetHwaccelType(state, options, "h264", bitDepth, hwSurface) + GetHwDecoderName(options, "h264
 6853                }
 6854
 06855                if (string.Equals(videoStream.Codec, "vc1", StringComparison.OrdinalIgnoreCase))
 6856                {
 06857                    return GetHwaccelType(state, options, "vc1", bitDepth, hwSurface) + GetHwDecoderName(options, "vc1",
 6858                }
 6859
 06860                if (string.Equals(videoStream.Codec, "vp8", StringComparison.OrdinalIgnoreCase))
 6861                {
 06862                    return GetHwaccelType(state, options, "vp8", bitDepth, hwSurface) + GetHwDecoderName(options, "vp8",
 6863                }
 6864
 06865                if (string.Equals(videoStream.Codec, "mpeg2video", StringComparison.OrdinalIgnoreCase))
 6866                {
 06867                    return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface) + GetHwDecoderName(options,
 6868                }
 6869            }
 6870
 06871            if (is8_10bitSwFormatsQsv)
 6872            {
 06873                if (string.Equals(videoStream.Codec, "vp9", StringComparison.OrdinalIgnoreCase))
 6874                {
 06875                    return GetHwaccelType(state, options, "vp9", bitDepth, hwSurface) + GetHwDecoderName(options, "vp9",
 6876                }
 6877
 06878                if (string.Equals(videoStream.Codec, "av1", StringComparison.OrdinalIgnoreCase))
 6879                {
 06880                    return GetHwaccelType(state, options, "av1", bitDepth, hwSurface) + GetHwDecoderName(options, "av1",
 6881                }
 6882            }
 6883
 06884            if (is8_10_12bitSwFormatsQsv)
 6885            {
 06886                if (string.Equals(videoStream.Codec, "hevc", StringComparison.OrdinalIgnoreCase)
 06887                    || string.Equals(videoStream.Codec, "h265", StringComparison.OrdinalIgnoreCase))
 6888                {
 06889                    return GetHwaccelType(state, options, "hevc", bitDepth, hwSurface) + GetHwDecoderName(options, "hevc
 6890                }
 6891            }
 6892
 06893            return null;
 6894        }
 6895
 6896        public string GetNvdecVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bi
 6897        {
 06898            if ((!OperatingSystem.IsWindows() && !OperatingSystem.IsLinux())
 06899                || options.HardwareAccelerationType != HardwareAccelerationType.nvenc)
 6900            {
 06901                return null;
 6902            }
 6903
 06904            var hwSurface = IsCudaFullSupported() && _mediaEncoder.SupportsFilter("alphasrc");
 06905            var is8bitSwFormatsNvdec = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreC
 06906                                       || string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgn
 06907            var is8_10bitSwFormatsNvdec = is8bitSwFormatsNvdec || string.Equals("yuv420p10le", videoStream.PixelFormat, 
 06908            var is8_10_12bitSwFormatsNvdec = is8_10bitSwFormatsNvdec
 06909                || string.Equals("yuv444p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06910                || string.Equals("yuv444p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06911                || string.Equals("yuv420p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 06912                || string.Equals("yuv444p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase);
 6913            // TODO: add more 8/10/12bit and 4:4:4 formats for Nvdec after finishing the ffcheck tool
 6914
 06915            if (is8bitSwFormatsNvdec)
 6916            {
 06917                if (string.Equals("avc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 06918                    || string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6919                {
 06920                    return GetHwaccelType(state, options, "h264", bitDepth, hwSurface) + GetHwDecoderName(options, "h264
 6921                }
 6922
 06923                if (string.Equals("mpeg2video", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6924                {
 06925                    return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface) + GetHwDecoderName(options,
 6926                }
 6927
 06928                if (string.Equals("vc1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6929                {
 06930                    return GetHwaccelType(state, options, "vc1", bitDepth, hwSurface) + GetHwDecoderName(options, "vc1",
 6931                }
 6932
 06933                if (string.Equals("mpeg4", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6934                {
 06935                    return GetHwaccelType(state, options, "mpeg4", bitDepth, hwSurface) + GetHwDecoderName(options, "mpe
 6936                }
 6937
 06938                if (string.Equals("vp8", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6939                {
 06940                    return GetHwaccelType(state, options, "vp8", bitDepth, hwSurface) + GetHwDecoderName(options, "vp8",
 6941                }
 6942            }
 6943
 06944            if (is8_10bitSwFormatsNvdec)
 6945            {
 06946                if (string.Equals("vp9", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6947                {
 06948                    return GetHwaccelType(state, options, "vp9", bitDepth, hwSurface) + GetHwDecoderName(options, "vp9",
 6949                }
 6950
 06951                if (string.Equals("av1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6952                {
 06953                    return GetHwaccelType(state, options, "av1", bitDepth, hwSurface) + GetHwDecoderName(options, "av1",
 6954                }
 6955            }
 6956
 06957            if (is8_10_12bitSwFormatsNvdec)
 6958            {
 06959                if (string.Equals("hevc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 06960                    || string.Equals("h265", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6961                {
 06962                    return GetHwaccelType(state, options, "hevc", bitDepth, hwSurface) + GetHwDecoderName(options, "hevc
 6963                }
 6964            }
 6965
 06966            return null;
 6967        }
 6968
 6969        public string GetAmfVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bitD
 6970        {
 06971            if (!OperatingSystem.IsWindows()
 06972                || options.HardwareAccelerationType != HardwareAccelerationType.amf)
 6973            {
 06974                return null;
 6975            }
 6976
 06977            var hwSurface = _mediaEncoder.SupportsHwaccel("d3d11va")
 06978                && IsOpenclFullSupported()
 06979                && _mediaEncoder.SupportsFilter("alphasrc");
 06980            var is8bitSwFormatsAmf = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCas
 06981                                     || string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgnor
 06982            var is8_10bitSwFormatsAmf = is8bitSwFormatsAmf || string.Equals("yuv420p10le", videoStream.PixelFormat, Stri
 6983
 06984            if (is8bitSwFormatsAmf)
 6985            {
 06986                if (string.Equals("avc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 06987                    || string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6988                {
 06989                    return GetHwaccelType(state, options, "h264", bitDepth, hwSurface);
 6990                }
 6991
 06992                if (string.Equals("mpeg2video", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6993                {
 06994                    return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface);
 6995                }
 6996
 06997                if (string.Equals("vc1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 6998                {
 06999                    return GetHwaccelType(state, options, "vc1", bitDepth, hwSurface);
 7000                }
 7001            }
 7002
 07003            if (is8_10bitSwFormatsAmf)
 7004            {
 07005                if (string.Equals("hevc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 07006                    || string.Equals("h265", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7007                {
 07008                    return GetHwaccelType(state, options, "hevc", bitDepth, hwSurface);
 7009                }
 7010
 07011                if (string.Equals("vp9", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7012                {
 07013                    return GetHwaccelType(state, options, "vp9", bitDepth, hwSurface);
 7014                }
 7015
 07016                if (string.Equals("av1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7017                {
 07018                    return GetHwaccelType(state, options, "av1", bitDepth, hwSurface);
 7019                }
 7020            }
 7021
 07022            return null;
 7023        }
 7024
 7025        public string GetVaapiVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bi
 7026        {
 07027            if (!OperatingSystem.IsLinux()
 07028                || options.HardwareAccelerationType != HardwareAccelerationType.vaapi)
 7029            {
 07030                return null;
 7031            }
 7032
 07033            var hwSurface = IsVaapiSupported(state)
 07034                && IsVaapiFullSupported()
 07035                && IsOpenclFullSupported()
 07036                && _mediaEncoder.SupportsFilter("alphasrc");
 07037            var is8bitSwFormatsVaapi = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreC
 07038                                       || string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgn
 07039            var is8_10bitSwFormatsVaapi = is8bitSwFormatsVaapi || string.Equals("yuv420p10le", videoStream.PixelFormat, 
 07040            var is8_10_12bitSwFormatsVaapi = is8_10bitSwFormatsVaapi
 07041                || string.Equals("yuv422p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07042                || string.Equals("yuv444p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07043                || string.Equals("yuv422p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07044                || string.Equals("yuv444p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07045                || string.Equals("yuv420p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07046                || string.Equals("yuv422p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07047                || string.Equals("yuv444p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase);
 7048
 07049            if (is8bitSwFormatsVaapi)
 7050            {
 07051                if (string.Equals("avc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 07052                    || string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7053                {
 07054                    return GetHwaccelType(state, options, "h264", bitDepth, hwSurface);
 7055                }
 7056
 07057                if (string.Equals("mpeg2video", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7058                {
 07059                    return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface);
 7060                }
 7061
 07062                if (string.Equals("vc1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7063                {
 07064                    return GetHwaccelType(state, options, "vc1", bitDepth, hwSurface);
 7065                }
 7066
 07067                if (string.Equals("vp8", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7068                {
 07069                    return GetHwaccelType(state, options, "vp8", bitDepth, hwSurface);
 7070                }
 7071            }
 7072
 07073            if (is8_10bitSwFormatsVaapi)
 7074            {
 07075                if (string.Equals("vp9", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7076                {
 07077                    return GetHwaccelType(state, options, "vp9", bitDepth, hwSurface);
 7078                }
 7079
 07080                if (string.Equals("av1", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7081                {
 07082                    return GetHwaccelType(state, options, "av1", bitDepth, hwSurface);
 7083                }
 7084            }
 7085
 07086            if (is8_10_12bitSwFormatsVaapi)
 7087            {
 07088                if (string.Equals("hevc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 07089                    || string.Equals("h265", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7090                {
 07091                    return GetHwaccelType(state, options, "hevc", bitDepth, hwSurface);
 7092                }
 7093            }
 7094
 07095            return null;
 7096        }
 7097
 7098        public string GetVideotoolboxVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream,
 7099        {
 07100            if (!OperatingSystem.IsMacOS()
 07101                || options.HardwareAccelerationType != HardwareAccelerationType.videotoolbox)
 7102            {
 07103                return null;
 7104            }
 7105
 07106            var is8bitSwFormatsVt = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase
 07107                                    || string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgnore
 07108            var is8_10bitSwFormatsVt = is8bitSwFormatsVt || string.Equals("yuv420p10le", videoStream.PixelFormat, String
 07109            var is8_10_12bitSwFormatsVt = is8_10bitSwFormatsVt
 07110                || string.Equals("yuv422p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07111                || string.Equals("yuv444p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07112                || string.Equals("yuv422p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07113                || string.Equals("yuv444p10le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07114                || string.Equals("yuv420p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07115                || string.Equals("yuv422p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase)
 07116                || string.Equals("yuv444p12le", videoStream.PixelFormat, StringComparison.OrdinalIgnoreCase);
 07117            var isAv1SupportedSwFormatsVt = is8_10bitSwFormatsVt || string.Equals("yuv420p12le", videoStream.PixelFormat
 7118
 7119            // The related patches make videotoolbox hardware surface working is only available in jellyfin-ffmpeg 7.0.1
 07120            bool useHwSurface = (_mediaEncoder.EncoderVersion >= _minFFmpegWorkingVtHwSurface) && IsVideoToolboxFullSupp
 7121
 07122            if (is8bitSwFormatsVt)
 7123            {
 07124                if (string.Equals("vp8", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7125                {
 07126                    return GetHwaccelType(state, options, "vp8", bitDepth, useHwSurface);
 7127                }
 7128            }
 7129
 07130            if (is8_10bitSwFormatsVt)
 7131            {
 07132                if (string.Equals("avc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 07133                    || string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7134                {
 07135                    return GetHwaccelType(state, options, "h264", bitDepth, useHwSurface);
 7136                }
 7137
 07138                if (string.Equals("vp9", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7139                {
 07140                    return GetHwaccelType(state, options, "vp9", bitDepth, useHwSurface);
 7141                }
 7142            }
 7143
 07144            if (is8_10_12bitSwFormatsVt)
 7145            {
 07146                if (string.Equals("hevc", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 07147                    || string.Equals("h265", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
 7148                {
 07149                    return GetHwaccelType(state, options, "hevc", bitDepth, useHwSurface);
 7150                }
 7151
 07152                if (string.Equals("av1", videoStream.Codec, StringComparison.OrdinalIgnoreCase)
 07153                    && isAv1SupportedSwFormatsVt
 07154                    && _mediaEncoder.IsVideoToolboxAv1DecodeAvailable)
 7155                {
 07156                    return GetHwaccelType(state, options, "av1", bitDepth, useHwSurface);
 7157                }
 7158            }
 7159
 07160            return null;
 7161        }
 7162
 7163        public string GetRkmppVidDecoder(EncodingJobInfo state, EncodingOptions options, MediaStream videoStream, int bi
 7164        {
 07165            var isLinux = OperatingSystem.IsLinux();
 7166
 07167            if (!isLinux
 07168                || options.HardwareAccelerationType != HardwareAccelerationType.rkmpp)
 7169            {
 07170                return null;
 7171            }
 7172
 07173            var inW = state.VideoStream?.Width;
 07174            var inH = state.VideoStream?.Height;
 07175            var reqW = state.BaseRequest.Width;
 07176            var reqH = state.BaseRequest.Height;
 07177            var reqMaxW = state.BaseRequest.MaxWidth;
 07178            var reqMaxH = state.BaseRequest.MaxHeight;
 7179
 7180            // rkrga RGA2e supports range from 1/16 to 16
 07181            if (!IsScaleRatioSupported(inW, inH, reqW, reqH, reqMaxW, reqMaxH, 16.0f))
 7182            {
 07183                return null;
 7184            }
 7185
 07186            var isRkmppOclSupported = IsRkmppFullSupported() && IsOpenclFullSupported();
 07187            var hwSurface = isRkmppOclSupported
 07188                && _mediaEncoder.SupportsFilter("alphasrc");
 7189
 7190            // rkrga RGA3 supports range from 1/8 to 8
 07191            var isAfbcSupported = hwSurface && IsScaleRatioSupported(inW, inH, reqW, reqH, reqMaxW, reqMaxH, 8.0f);
 7192
 7193            // TODO: add more 8/10bit and 4:2:2 formats for Rkmpp after finishing the ffcheck tool
 07194            var is8bitSwFormatsRkmpp = string.Equals("yuv420p", videoStream.PixelFormat, StringComparison.OrdinalIgnoreC
 07195                                       || string.Equals("yuvj420p", videoStream.PixelFormat, StringComparison.OrdinalIgn
 07196            var is10bitSwFormatsRkmpp = string.Equals("yuv420p10le", videoStream.PixelFormat, StringComparison.OrdinalIg
 07197            var is8_10bitSwFormatsRkmpp = is8bitSwFormatsRkmpp || is10bitSwFormatsRkmpp;
 7198
 7199            // nv15 and nv20 are bit-stream only formats
 07200            if (is10bitSwFormatsRkmpp && !hwSurface)
 7201            {
 07202                return null;
 7203            }
 7204
 07205            if (is8bitSwFormatsRkmpp)
 7206            {
 07207                if (string.Equals(videoStream.Codec, "mpeg1video", StringComparison.OrdinalIgnoreCase))
 7208                {
 07209                    return GetHwaccelType(state, options, "mpeg1video", bitDepth, hwSurface);
 7210                }
 7211
 07212                if (string.Equals(videoStream.Codec, "mpeg2video", StringComparison.OrdinalIgnoreCase))
 7213                {
 07214                    return GetHwaccelType(state, options, "mpeg2video", bitDepth, hwSurface);
 7215                }
 7216
 07217                if (string.Equals(videoStream.Codec, "mpeg4", StringComparison.OrdinalIgnoreCase))
 7218                {
 07219                    return GetHwaccelType(state, options, "mpeg4", bitDepth, hwSurface);
 7220                }
 7221
 07222                if (string.Equals(videoStream.Codec, "vp8", StringComparison.OrdinalIgnoreCase))
 7223                {
 07224                    return GetHwaccelType(state, options, "vp8", bitDepth, hwSurface);
 7225                }
 7226            }
 7227
 07228            if (is8_10bitSwFormatsRkmpp)
 7229            {
 07230                if (string.Equals(videoStream.Codec, "avc", StringComparison.OrdinalIgnoreCase)
 07231                    || string.Equals(videoStream.Codec, "h264", StringComparison.OrdinalIgnoreCase))
 7232                {
 07233                    var accelType = GetHwaccelType(state, options, "h264", bitDepth, hwSurface);
 07234                    return accelType + ((!string.IsNullOrEmpty(accelType) && isAfbcSupported) ? " -afbc rga" : string.Em
 7235                }
 7236
 07237                if (string.Equals(videoStream.Codec, "hevc", StringComparison.OrdinalIgnoreCase)
 07238                    || string.Equals(videoStream.Codec, "h265", StringComparison.OrdinalIgnoreCase))
 7239                {
 07240                    var accelType = GetHwaccelType(state, options, "hevc", bitDepth, hwSurface);
 07241                    return accelType + ((!string.IsNullOrEmpty(accelType) && isAfbcSupported) ? " -afbc rga" : string.Em
 7242                }
 7243
 07244                if (string.Equals(videoStream.Codec, "vp9", StringComparison.OrdinalIgnoreCase))
 7245                {
 07246                    var accelType = GetHwaccelType(state, options, "vp9", bitDepth, hwSurface);
 07247                    return accelType + ((!string.IsNullOrEmpty(accelType) && isAfbcSupported) ? " -afbc rga" : string.Em
 7248                }
 7249
 07250                if (string.Equals(videoStream.Codec, "av1", StringComparison.OrdinalIgnoreCase))
 7251                {
 7252                    // there's an issue about AV1 AFBC on RK3588, disable it for now until it's fixed upstream
 07253                    return GetHwaccelType(state, options, "av1", bitDepth, hwSurface);
 7254                }
 7255            }
 7256
 07257            return null;
 7258        }
 7259
 7260        /// <summary>
 7261        /// Gets the number of threads.
 7262        /// </summary>
 7263        /// <param name="state">Encoding state.</param>
 7264        /// <param name="encodingOptions">Encoding options.</param>
 7265        /// <param name="outputVideoCodec">Video codec to use.</param>
 7266        /// <returns>Number of threads.</returns>
 7267#nullable enable
 7268        public static int GetNumberOfThreads(EncodingJobInfo? state, EncodingOptions encodingOptions, string? outputVide
 7269        {
 147270            var threads = state?.BaseRequest.CpuCoreLimit ?? encodingOptions.EncodingThreadCount;
 7271
 147272            if (threads <= 0)
 7273            {
 7274                // Automatically set thread count
 147275                return 0;
 7276            }
 7277
 07278            return Math.Min(threads, Environment.ProcessorCount);
 7279        }
 7280
 7281#nullable disable
 7282        public void TryStreamCopy(EncodingJobInfo state, EncodingOptions options)
 7283        {
 07284            if (state.VideoStream is not null && CanStreamCopyVideo(state, state.VideoStream))
 7285            {
 07286                state.OutputVideoCodec = "copy";
 7287            }
 7288            else
 7289            {
 07290                var user = state.User;
 7291
 7292                // If the user doesn't have access to transcoding, then force stream copy, regardless of whether it will
 07293                if (user is not null && !user.HasPermission(PermissionKind.EnableVideoPlaybackTranscoding))
 7294                {
 07295                    state.OutputVideoCodec = "copy";
 7296                }
 7297            }
 7298
 07299            var preventHlsAudioCopy = state.TranscodingType is TranscodingJobType.Hls
 07300                && state.VideoStream is not null
 07301                && !IsCopyCodec(state.OutputVideoCodec)
 07302                && options.HlsAudioSeekStrategy is HlsAudioSeekStrategy.TranscodeAudio;
 7303
 07304            TranscodeReason audioCopyFailureReasons = 0;
 07305            if (state.AudioStream is not null
 07306                && CanStreamCopyAudio(state, state.AudioStream, state.SupportedAudioCodecs, out audioCopyFailureReasons)
 07307                && !preventHlsAudioCopy)
 7308            {
 07309                state.OutputAudioCodec = "copy";
 7310            }
 7311            else
 7312            {
 07313                var user = state.User;
 7314
 7315                // If the user doesn't have access to transcoding, then force stream copy, regardless of whether it will
 07316                if (user is not null && !user.HasPermission(PermissionKind.EnableAudioPlaybackTranscoding))
 7317                {
 07318                    state.OutputAudioCodec = "copy";
 7319                }
 07320                else if (state.AudioStream is not null && !IsCopyCodec(state.OutputAudioCodec))
 7321                {
 7322                    // Audio is actually being re-encoded although the playback determination may have considered the so
 7323                    // Only carry the primary "cannot be passed through" cause - the codec mismatch.
 7324                    // Bitrate/channels/sample-rate/bit-depth copy refusals are consequences of the chosen transcode tar
 07325                    state.AddTranscodeReason(audioCopyFailureReasons & TranscodeReason.AudioCodecNotSupported);
 7326                }
 7327            }
 07328        }
 7329
 7330        private string GetFfmpegAnalyzeDurationArg(EncodingJobInfo state)
 7331        {
 187332            var analyzeDurationArgument = string.Empty;
 7333
 7334            // Apply -analyzeduration as per the environment variable,
 7335            // otherwise ffmpeg will break on certain files due to default value is 0.
 187336            var ffmpegAnalyzeDuration = _config.GetFFmpegAnalyzeDuration() ?? string.Empty;
 7337
 187338            if (state.MediaSource.AnalyzeDurationMs > 0)
 7339            {
 07340                analyzeDurationArgument = "-analyzeduration " + (state.MediaSource.AnalyzeDurationMs.Value * 1000).ToStr
 7341            }
 187342            else if (!string.IsNullOrEmpty(ffmpegAnalyzeDuration))
 7343            {
 07344                analyzeDurationArgument = "-analyzeduration " + ffmpegAnalyzeDuration;
 7345            }
 7346
 187347            return analyzeDurationArgument;
 7348        }
 7349
 7350        private string GetFfmpegProbesizeArg()
 7351        {
 187352            var ffmpegProbeSize = _config.GetFFmpegProbeSize();
 7353
 187354            if (!string.IsNullOrEmpty(ffmpegProbeSize))
 7355            {
 07356                return $"-probesize {ffmpegProbeSize}";
 7357            }
 7358
 187359            return string.Empty;
 7360        }
 7361
 7362        public string GetInputModifier(EncodingJobInfo state, EncodingOptions encodingOptions, string segmentContainer)
 7363        {
 147364            var inputModifier = string.Empty;
 147365            var analyzeDurationArgument = GetFfmpegAnalyzeDurationArg(state);
 7366
 147367            if (!string.IsNullOrEmpty(analyzeDurationArgument))
 7368            {
 07369                inputModifier += " " + analyzeDurationArgument;
 7370            }
 7371
 147372            inputModifier = inputModifier.Trim();
 7373
 7374            // Apply -probesize if configured
 147375            var ffmpegProbeSizeArgument = GetFfmpegProbesizeArg();
 7376
 147377            if (!string.IsNullOrEmpty(ffmpegProbeSizeArgument))
 7378            {
 07379                inputModifier += " " + ffmpegProbeSizeArgument;
 7380            }
 7381
 147382            var userAgentParam = GetUserAgentParam(state);
 7383
 147384            if (!string.IsNullOrEmpty(userAgentParam))
 7385            {
 07386                inputModifier += " " + userAgentParam;
 7387            }
 7388
 147389            inputModifier = inputModifier.Trim();
 7390
 147391            var refererParam = GetRefererParam(state);
 7392
 147393            if (!string.IsNullOrEmpty(refererParam))
 7394            {
 07395                inputModifier += " " + refererParam;
 7396            }
 7397
 147398            inputModifier = inputModifier.Trim();
 7399
 147400            inputModifier += " " + GetFastSeekCommandLineParameter(state, encodingOptions, segmentContainer);
 147401            inputModifier = inputModifier.Trim();
 7402
 147403            if (state.InputProtocol == MediaProtocol.Rtsp)
 7404            {
 07405                inputModifier += " -rtsp_transport tcp+udp -rtsp_flags prefer_tcp";
 7406            }
 7407
 147408            if (!string.IsNullOrEmpty(state.InputAudioSync))
 7409            {
 07410                inputModifier += " -async " + state.InputAudioSync;
 7411            }
 7412
 7413            // The -fps_mode option cannot be applied to input
 147414            if (!string.IsNullOrEmpty(state.InputVideoSync) && _mediaEncoder.EncoderVersion < new Version(5, 1))
 7415            {
 07416                inputModifier += GetVideoSyncOption(state.InputVideoSync, _mediaEncoder.EncoderVersion);
 7417            }
 7418
 147419            int readrate = 0;
 147420            if (state.ReadInputAtNativeFramerate && state.InputProtocol != MediaProtocol.Rtsp)
 7421            {
 07422                readrate = 1;
 07423                inputModifier += " -re";
 7424            }
 147425            else if (encodingOptions.EnableSegmentDeletion
 147426                && state.VideoStream is not null
 147427                && state.TranscodingType == TranscodingJobType.Hls
 147428                && IsCopyCodec(state.OutputVideoCodec)
 147429                && _mediaEncoder.EncoderVersion >= _minFFmpegReadrateOption)
 7430            {
 7431                // Set an input read rate limit 10x for using SegmentDeletion with stream-copy
 7432                // to prevent ffmpeg from exiting prematurely (due to fast drive)
 07433                readrate = 10;
 07434                inputModifier += $" -readrate {readrate}";
 7435            }
 7436
 7437            // Set a larger catchup value to revert to the old behavior,
 7438            // otherwise, remuxing might stall due to this new option
 147439            if (readrate > 0 && _mediaEncoder.EncoderVersion >= _minFFmpegReadrateCatchupOption)
 7440            {
 07441                inputModifier += $" -readrate_catchup {readrate * 100}";
 7442            }
 7443
 147444            var flags = new List<string>();
 147445            if (state.IgnoreInputDts)
 7446            {
 07447                flags.Add("+igndts");
 7448            }
 7449
 147450            if (state.IgnoreInputIndex)
 7451            {
 07452                flags.Add("+ignidx");
 7453            }
 7454
 147455            if (state.GenPtsInput || IsCopyCodec(state.OutputVideoCodec))
 7456            {
 07457                flags.Add("+genpts");
 7458            }
 7459
 147460            if (state.DiscardCorruptFramesInput)
 7461            {
 07462                flags.Add("+discardcorrupt");
 7463            }
 7464
 147465            if (state.EnableFastSeekInput)
 7466            {
 07467                flags.Add("+fastseek");
 7468            }
 7469
 147470            if (flags.Count > 0)
 7471            {
 07472                inputModifier += " -fflags " + string.Join(string.Empty, flags);
 7473            }
 7474
 147475            if (state.IsVideoRequest)
 7476            {
 07477                if (!string.IsNullOrEmpty(state.InputContainer) && state.VideoType == VideoType.VideoFile && encodingOpt
 7478                {
 07479                    var inputFormat = GetInputFormat(state.InputContainer);
 07480                    if (!string.IsNullOrEmpty(inputFormat))
 7481                    {
 07482                        inputModifier += " -f " + inputFormat;
 7483                    }
 7484                }
 7485            }
 7486
 147487            if (state.MediaSource.RequiresLooping)
 7488            {
 07489                inputModifier += " -stream_loop -1 -reconnect_at_eof 1 -reconnect_streamed 1 -reconnect_delay_max 2";
 7490            }
 7491
 147492            return inputModifier;
 7493        }
 7494
 7495        public void AttachMediaSourceInfo(
 7496            EncodingJobInfo state,
 7497            EncodingOptions encodingOptions,
 7498            MediaSourceInfo mediaSource,
 7499            string requestedUrl)
 7500        {
 237501            ArgumentNullException.ThrowIfNull(state);
 7502
 237503            ArgumentNullException.ThrowIfNull(mediaSource);
 7504
 237505            var path = mediaSource.Path;
 237506            var protocol = mediaSource.Protocol;
 7507
 237508            if (!string.IsNullOrEmpty(mediaSource.EncoderPath) && mediaSource.EncoderProtocol.HasValue)
 7509            {
 07510                path = mediaSource.EncoderPath;
 07511                protocol = mediaSource.EncoderProtocol.Value;
 7512            }
 7513
 237514            state.MediaPath = path;
 237515            state.InputProtocol = protocol;
 237516            state.InputContainer = mediaSource.Container;
 237517            state.RunTimeTicks = mediaSource.RunTimeTicks;
 237518            state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;
 7519
 237520            state.IsoType = mediaSource.IsoType;
 7521
 237522            if (mediaSource.Timestamp.HasValue)
 7523            {
 07524                state.InputTimestamp = mediaSource.Timestamp.Value;
 7525            }
 7526
 237527            state.RunTimeTicks = mediaSource.RunTimeTicks;
 237528            state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;
 237529            state.ReadInputAtNativeFramerate = mediaSource.ReadAtNativeFramerate;
 7530
 237531            if ((state.ReadInputAtNativeFramerate && !state.IsSegmentedLiveStream)
 237532                || (mediaSource.Protocol == MediaProtocol.File
 237533                && string.Equals(mediaSource.Container, "wtv", StringComparison.OrdinalIgnoreCase)))
 7534            {
 07535                state.InputVideoSync = "-1";
 07536                state.InputAudioSync = "1";
 7537            }
 7538
 237539            if (string.Equals(mediaSource.Container, "wma", StringComparison.OrdinalIgnoreCase)
 237540                || string.Equals(mediaSource.Container, "asf", StringComparison.OrdinalIgnoreCase))
 7541            {
 7542                // Seeing some stuttering when transcoding wma to audio-only HLS
 07543                state.InputAudioSync = "1";
 7544            }
 7545
 237546            var mediaStreams = mediaSource.MediaStreams;
 7547
 237548            if (state.IsVideoRequest)
 7549            {
 07550                var videoRequest = state.BaseRequest;
 7551
 07552                if (string.IsNullOrEmpty(videoRequest.VideoCodec))
 7553                {
 07554                    if (string.IsNullOrEmpty(requestedUrl))
 7555                    {
 07556                        requestedUrl = "test." + videoRequest.Container;
 7557                    }
 7558
 07559                    videoRequest.VideoCodec = InferVideoCodec(requestedUrl);
 7560                }
 7561
 07562                state.VideoStream = GetMediaStream(mediaStreams, videoRequest.VideoStreamIndex, MediaStreamType.Video);
 07563                state.SubtitleStream = GetMediaStream(mediaStreams, videoRequest.SubtitleStreamIndex, MediaStreamType.Su
 07564                state.SubtitleDeliveryMethod = videoRequest.SubtitleMethod;
 07565                state.AudioStream = GetMediaStream(mediaStreams, videoRequest.AudioStreamIndex, MediaStreamType.Audio);
 7566
 07567                if (state.SubtitleStream is not null && !state.SubtitleStream.IsExternal)
 7568                {
 07569                    state.InternalSubtitleStreamOffset = mediaStreams.Where(i => i.Type == MediaStreamType.Subtitle && !
 7570                }
 7571
 07572                EnforceResolutionLimit(state);
 7573
 07574                NormalizeSubtitleEmbed(state);
 7575            }
 7576            else
 7577            {
 237578                state.AudioStream = GetMediaStream(mediaStreams, null, MediaStreamType.Audio, true);
 7579            }
 7580
 237581            state.MediaSource = mediaSource;
 7582
 237583            var request = state.BaseRequest;
 237584            var supportedAudioCodecs = state.SupportedAudioCodecs;
 237585            if (request is not null && supportedAudioCodecs is not null && supportedAudioCodecs.Length > 0)
 7586            {
 237587                var supportedAudioCodecsList = supportedAudioCodecs.ToList();
 7588
 237589                ShiftAudioCodecsIfNeeded(supportedAudioCodecsList, state.AudioStream);
 7590
 237591                state.SupportedAudioCodecs = supportedAudioCodecsList.ToArray();
 7592
 237593                request.AudioCodec = state.SupportedAudioCodecs.FirstOrDefault(_mediaEncoder.CanEncodeToAudioCodec)
 237594                    ?? state.SupportedAudioCodecs.FirstOrDefault();
 7595            }
 7596
 237597            var supportedVideoCodecs = state.SupportedVideoCodecs;
 237598            if (request is not null && supportedVideoCodecs is not null && supportedVideoCodecs.Length > 0)
 7599            {
 07600                var supportedVideoCodecsList = supportedVideoCodecs.ToList();
 7601
 07602                ShiftVideoCodecsIfNeeded(supportedVideoCodecsList, encodingOptions);
 7603
 07604                state.SupportedVideoCodecs = supportedVideoCodecsList.ToArray();
 7605
 07606                request.VideoCodec = state.SupportedVideoCodecs.FirstOrDefault();
 7607            }
 237608        }
 7609
 7610        private void ShiftAudioCodecsIfNeeded(List<string> audioCodecs, MediaStream audioStream)
 7611        {
 7612            // No need to shift if there is only one supported audio codec.
 237613            if (audioCodecs.Count < 2)
 7614            {
 237615                return;
 7616            }
 7617
 07618            var inputChannels = audioStream is null ? 6 : audioStream.Channels ?? 6;
 07619            var shiftAudioCodecs = new List<string>();
 07620            if (inputChannels >= 6)
 7621            {
 7622                // DTS and TrueHD are not supported by HLS
 7623                // Keep them in the supported codecs list, but shift them to the end of the list so that if transcoding 
 07624                shiftAudioCodecs.Add("dts");
 07625                shiftAudioCodecs.Add("truehd");
 7626            }
 7627            else
 7628            {
 7629                // Transcoding to 2ch ac3 or eac3 almost always causes a playback failure
 7630                // Keep them in the supported codecs list, but shift them to the end of the list so that if transcoding 
 07631                shiftAudioCodecs.Add("ac3");
 07632                shiftAudioCodecs.Add("eac3");
 7633            }
 7634
 07635            if (audioCodecs.All(i => shiftAudioCodecs.Contains(i, StringComparison.OrdinalIgnoreCase)))
 7636            {
 07637                return;
 7638            }
 7639
 07640            while (shiftAudioCodecs.Contains(audioCodecs[0], StringComparison.OrdinalIgnoreCase))
 7641            {
 07642                var removed = audioCodecs[0];
 07643                audioCodecs.RemoveAt(0);
 07644                audioCodecs.Add(removed);
 7645            }
 07646        }
 7647
 7648        private void ShiftVideoCodecsIfNeeded(List<string> videoCodecs, EncodingOptions encodingOptions)
 7649        {
 7650            // No need to shift if there is only one supported video codec.
 07651            if (videoCodecs.Count < 2)
 7652            {
 07653                return;
 7654            }
 7655
 7656            // Shift codecs to the end of list if it's not allowed.
 07657            var shiftVideoCodecs = new List<string>();
 07658            if (!encodingOptions.AllowHevcEncoding)
 7659            {
 07660                shiftVideoCodecs.Add("hevc");
 07661                shiftVideoCodecs.Add("h265");
 7662            }
 7663
 07664            if (!encodingOptions.AllowAv1Encoding)
 7665            {
 07666                shiftVideoCodecs.Add("av1");
 7667            }
 7668
 07669            if (videoCodecs.All(i => shiftVideoCodecs.Contains(i, StringComparison.OrdinalIgnoreCase)))
 7670            {
 07671                return;
 7672            }
 7673
 07674            while (shiftVideoCodecs.Contains(videoCodecs[0], StringComparison.OrdinalIgnoreCase))
 7675            {
 07676                var removed = videoCodecs[0];
 07677                videoCodecs.RemoveAt(0);
 07678                videoCodecs.Add(removed);
 7679            }
 07680        }
 7681
 7682        private void NormalizeSubtitleEmbed(EncodingJobInfo state)
 7683        {
 07684            if (state.SubtitleStream is null || state.SubtitleDeliveryMethod != SubtitleDeliveryMethod.Embed)
 7685            {
 07686                return;
 7687            }
 7688
 7689            // This is tricky to remux in, after converting to dvdsub it's not positioned correctly
 7690            // Therefore, let's just burn it in
 07691            if (string.Equals(state.SubtitleStream.Codec, "DVBSUB", StringComparison.OrdinalIgnoreCase))
 7692            {
 07693                state.SubtitleDeliveryMethod = SubtitleDeliveryMethod.Encode;
 7694            }
 07695        }
 7696
 7697        public string GetSubtitleEmbedArguments(EncodingJobInfo state)
 7698        {
 07699            if (state.SubtitleStream is null || state.SubtitleDeliveryMethod != SubtitleDeliveryMethod.Embed)
 7700            {
 07701                return string.Empty;
 7702            }
 7703
 07704            var format = state.SupportedSubtitleCodecs.FirstOrDefault();
 7705            string codec;
 7706
 07707            if (string.IsNullOrEmpty(format) || string.Equals(format, state.SubtitleStream.Codec, StringComparison.Ordin
 7708            {
 07709                codec = "copy";
 7710            }
 7711            else
 7712            {
 07713                codec = format;
 7714            }
 7715
 07716            return " -codec:s:0 " + codec + " -disposition:s:0 default";
 7717        }
 7718
 7719        public string GetProgressiveVideoFullCommandLine(EncodingJobInfo state, EncodingOptions encodingOptions, Encoder
 7720        {
 7721            // Get the output codec name
 07722            var videoCodec = GetVideoEncoder(state, encodingOptions);
 7723
 07724            var format = string.Empty;
 07725            var keyFrame = string.Empty;
 07726            var outputPath = state.OutputFilePath;
 7727
 07728            if (Path.GetExtension(outputPath.AsSpan()).Equals(".mp4", StringComparison.OrdinalIgnoreCase)
 07729                && state.BaseRequest.Context == EncodingContext.Streaming)
 7730            {
 7731                // Comparison: https://github.com/jansmolders86/mediacenterjs/blob/master/lib/transcoding/desktop.js
 07732                format = " -f mp4 -movflags frag_keyframe+empty_moov+delay_moov";
 7733            }
 7734
 07735            var threads = GetNumberOfThreads(state, encodingOptions, videoCodec);
 7736
 07737            var inputModifier = GetInputModifier(state, encodingOptions, null);
 7738
 07739            return string.Format(
 07740                CultureInfo.InvariantCulture,
 07741                "{0} {1}{2} {3} {4} -map_metadata -1 -map_chapters -1 -threads {5} {6}{7}{8} -y \"{9}\"",
 07742                inputModifier,
 07743                GetInputArgument(state, encodingOptions, null),
 07744                keyFrame,
 07745                GetMapArgs(state),
 07746                GetProgressiveVideoArguments(state, encodingOptions, videoCodec, defaultPreset),
 07747                threads,
 07748                GetProgressiveVideoAudioArguments(state, encodingOptions),
 07749                GetSubtitleEmbedArguments(state),
 07750                format,
 07751                outputPath).Trim();
 7752        }
 7753
 7754        public string GetOutputFFlags(EncodingJobInfo state)
 7755        {
 07756            var flags = new List<string>();
 07757            if (state.GenPtsOutput)
 7758            {
 07759                flags.Add("+genpts");
 7760            }
 7761
 07762            if (flags.Count > 0)
 7763            {
 07764                return " -fflags " + string.Join(string.Empty, flags);
 7765            }
 7766
 07767            return string.Empty;
 7768        }
 7769
 7770        public string GetProgressiveVideoArguments(EncodingJobInfo state, EncodingOptions encodingOptions, string videoC
 7771        {
 07772            var args = "-codec:v:0 " + videoCodec;
 7773
 07774            if (state.BaseRequest.EnableMpegtsM2TsMode)
 7775            {
 07776                args += " -mpegts_m2ts_mode 1";
 7777            }
 7778
 07779            if (IsCopyCodec(videoCodec))
 7780            {
 07781                if (state.VideoStream is not null
 07782                    && string.Equals(state.OutputContainer, "ts", StringComparison.OrdinalIgnoreCase)
 07783                    && !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase))
 7784                {
 07785                    string bitStreamArgs = GetBitStreamArgs(state, MediaStreamType.Video);
 07786                    if (!string.IsNullOrEmpty(bitStreamArgs))
 7787                    {
 07788                        args += " " + bitStreamArgs;
 7789                    }
 7790                }
 7791
 07792                if (state.RunTimeTicks.HasValue && state.BaseRequest.CopyTimestamps)
 7793                {
 07794                    args += " -copyts -avoid_negative_ts disabled -start_at_zero";
 7795                }
 7796
 07797                if (!state.RunTimeTicks.HasValue)
 7798                {
 07799                    args += " -fflags +genpts";
 7800                }
 7801            }
 7802            else
 7803            {
 07804                var keyFrameArg = string.Format(
 07805                    CultureInfo.InvariantCulture,
 07806                    " -force_key_frames \"expr:gte(t,n_forced*{0})\"",
 07807                    5);
 7808
 07809                args += keyFrameArg;
 7810
 07811                var hasGraphicalSubs = state.SubtitleStream is not null && !state.SubtitleStream.IsTextSubtitleStream &&
 7812
 07813                var hasCopyTs = false;
 7814
 7815                // video processing filters.
 07816                var videoProcessParam = GetVideoProcessingFilterParam(state, encodingOptions, videoCodec);
 7817
 07818                var negativeMapArgs = GetNegativeMapArgsByFilters(state, videoProcessParam);
 7819
 07820                args = negativeMapArgs + args + videoProcessParam;
 7821
 07822                hasCopyTs = videoProcessParam.Contains("copyts", StringComparison.OrdinalIgnoreCase);
 7823
 07824                if (state.RunTimeTicks.HasValue && state.BaseRequest.CopyTimestamps)
 7825                {
 07826                    if (!hasCopyTs)
 7827                    {
 07828                        args += " -copyts";
 7829                    }
 7830
 07831                    args += " -avoid_negative_ts disabled";
 7832
 07833                    if (!(state.SubtitleStream is not null && state.SubtitleStream.IsExternal && !state.SubtitleStream.I
 7834                    {
 07835                        args += " -start_at_zero";
 7836                    }
 7837                }
 7838
 07839                var qualityParam = GetVideoQualityParam(state, videoCodec, encodingOptions, defaultPreset);
 7840
 07841                if (!string.IsNullOrEmpty(qualityParam))
 7842                {
 07843                    args += " " + qualityParam.Trim();
 7844                }
 7845            }
 7846
 07847            if (!string.IsNullOrEmpty(state.OutputVideoSync))
 7848            {
 07849                args += GetVideoSyncOption(state.OutputVideoSync, _mediaEncoder.EncoderVersion);
 7850            }
 7851
 07852            args += GetOutputFFlags(state);
 7853
 07854            return args;
 7855        }
 7856
 7857        public string GetProgressiveVideoAudioArguments(EncodingJobInfo state, EncodingOptions encodingOptions)
 7858        {
 7859            // If the video doesn't have an audio stream, return a default.
 37860            if (state.AudioStream is null && state.VideoStream is not null)
 7861            {
 07862                return string.Empty;
 7863            }
 7864
 7865            // Get the output codec name
 37866            var codec = GetAudioEncoder(state);
 7867
 37868            var args = "-codec:a:0 " + codec;
 7869
 37870            if (IsCopyCodec(codec))
 7871            {
 07872                return args;
 7873            }
 7874
 37875            var channels = state.OutputAudioChannels;
 7876
 7877            // Must match the condition under which GetAudioFilterParam emits the downmix filter.
 37878            var useDownMixAlgorithm = channels == 2
 37879                                      && state.AudioStream?.Channels > 2
 37880                                      && DownMixAlgorithmsHelper.AlgorithmFilterStrings.ContainsKey((encodingOptions.Dow
 7881
 37882            if (channels.HasValue && !useDownMixAlgorithm)
 7883            {
 27884                args += " -ac " + channels.Value;
 7885            }
 7886
 37887            var bitrate = state.OutputAudioBitrate;
 37888            if (bitrate.HasValue && !LosslessAudioCodecs.Contains(codec, StringComparison.OrdinalIgnoreCase))
 7889            {
 07890                var vbrParam = GetAudioVbrModeParam(codec, bitrate.Value, channels ?? 2);
 07891                if (encodingOptions.EnableAudioVbr && state.EnableAudioVbrEncoding && vbrParam is not null)
 7892                {
 07893                    args += vbrParam;
 7894                }
 7895                else
 7896                {
 07897                    args += " -ab " + bitrate.Value.ToString(CultureInfo.InvariantCulture);
 7898                }
 7899            }
 7900
 37901            if (state.OutputAudioSampleRate.HasValue)
 7902            {
 37903                args += " -ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture);
 7904            }
 7905
 37906            args += GetAudioFilterParam(state, encodingOptions);
 7907
 37908            return args;
 7909        }
 7910
 7911        public string GetProgressiveAudioFullCommandLine(EncodingJobInfo state, EncodingOptions encodingOptions, string 
 7912        {
 147913            var audioTranscodeParams = new List<string>();
 7914
 147915            var bitrate = state.OutputAudioBitrate;
 147916            var channels = state.OutputAudioChannels;
 147917            var outputCodec = state.OutputAudioCodec;
 7918
 147919            if (bitrate.HasValue && !LosslessAudioCodecs.Contains(outputCodec, StringComparison.OrdinalIgnoreCase))
 7920            {
 07921                var vbrParam = GetAudioVbrModeParam(GetAudioEncoder(state), bitrate.Value, channels ?? 2);
 07922                if (encodingOptions.EnableAudioVbr && state.EnableAudioVbrEncoding && vbrParam is not null)
 7923                {
 07924                    audioTranscodeParams.Add(vbrParam);
 7925                }
 7926                else
 7927                {
 07928                    audioTranscodeParams.Add("-ab " + bitrate.Value.ToString(CultureInfo.InvariantCulture));
 7929                }
 7930            }
 7931
 147932            if (channels.HasValue)
 7933            {
 27934                audioTranscodeParams.Add("-ac " + state.OutputAudioChannels.Value.ToString(CultureInfo.InvariantCulture)
 7935            }
 7936
 147937            if (!string.IsNullOrEmpty(outputCodec))
 7938            {
 147939                audioTranscodeParams.Add("-acodec " + GetAudioEncoder(state));
 7940            }
 7941
 7942            // The pcm_* encoders emit raw samples that carry no header of their own, so the header
 7943            // has to come from the muxer. Only force the matching raw muxer when the client actually
 7944            // asked for a raw container (added in #10321 for I2S/MCU clients): applying it to every
 7945            // pcm_* codec also strips the RIFF header from a `stream.wav` request, which then serves
 7946            // headerless PCM behind an audio/wav content type.
 147947            var audioEncoder = GetAudioEncoder(state);
 147948            if (audioEncoder.StartsWith("pcm_", StringComparison.Ordinal)
 147949                && string.Equals(state.OutputContainer, "pcm", StringComparison.OrdinalIgnoreCase))
 7950            {
 17951                audioTranscodeParams.Add(string.Concat("-f ", audioEncoder.AsSpan(4)));
 7952            }
 7953
 147954            var sampleRate = state.OutputAudioSampleRate;
 147955            if (sampleRate.HasValue)
 7956            {
 147957                var sampleRateValue = sampleRate.Value;
 147958                if (string.Equals(outputCodec, "opus", StringComparison.OrdinalIgnoreCase))
 7959                {
 7960                    // opus only supports specific sampling rates
 37961                    sampleRateValue = sampleRate.Value switch
 37962                    {
 17963                        <= 8000 => 8000,
 07964                        <= 12000 => 12000,
 07965                        <= 16000 => 16000,
 17966                        <= 24000 => 24000,
 17967                        _ => 48000
 37968                    };
 7969                }
 7970
 147971                audioTranscodeParams.Add("-ar " + sampleRateValue.ToString(CultureInfo.InvariantCulture));
 7972            }
 7973
 7974            // Without the downmix filter, -ac 2 alone drops the LFE channel.
 147975            var audioFilterParam = GetAudioFilterParam(state, encodingOptions);
 147976            if (!string.IsNullOrEmpty(audioFilterParam))
 7977            {
 17978                audioTranscodeParams.Add(audioFilterParam.TrimStart());
 7979            }
 7980
 7981            // Copy the movflags from GetProgressiveVideoFullCommandLine
 7982            // See #9248 and the associated PR for why this is needed
 147983            if (_mp4ContainerNames.Contains(state.OutputContainer))
 7984            {
 07985                audioTranscodeParams.Add("-movflags empty_moov+delay_moov");
 7986            }
 7987
 147988            var threads = GetNumberOfThreads(state, encodingOptions, null);
 7989
 147990            var inputModifier = GetInputModifier(state, encodingOptions, null);
 7991
 147992            return string.Format(
 147993                CultureInfo.InvariantCulture,
 147994                "{0} {1}{7}{8} -threads {2}{3} {4} -id3v2_version 3 -write_id3v1 1{6} -y \"{5}\"",
 147995                inputModifier,
 147996                GetInputArgument(state, encodingOptions, null),
 147997                threads,
 147998                " -vn",
 147999                string.Join(' ', audioTranscodeParams),
 148000                outputPath,
 148001                string.Empty,
 148002                string.Empty,
 148003                string.Empty).Trim();
 8004        }
 8005
 8006        public static int FindIndex(IReadOnlyList<MediaStream> mediaStreams, MediaStream streamToFind)
 8007        {
 168008            var index = 0;
 168009            var length = mediaStreams.Count;
 8010
 568011            for (var i = 0; i < length; i++)
 8012            {
 288013                var currentMediaStream = mediaStreams[i];
 288014                if (currentMediaStream == streamToFind)
 8015                {
 168016                    return index;
 8017                }
 8018
 128019                if (string.Equals(currentMediaStream.Path, streamToFind.Path, StringComparison.Ordinal))
 8020                {
 128021                    index++;
 8022                }
 8023            }
 8024
 08025            return -1;
 8026        }
 8027
 8028        public static int GetSubtitleStreamIndexForFfmpeg(MediaSourceInfo mediaSource, MediaStream subtitleStream)
 8029        {
 08030            var index = FindIndex(mediaSource.MediaStreams, subtitleStream);
 08031            if (index == -1 || subtitleStream.IsExternal || mediaSource.VideoType != VideoType.BluRay)
 8032            {
 08033                return index;
 8034            }
 8035
 08036            var hiddenStreamsBefore = mediaSource.MediaStreams.Count(s =>
 08037                s.Type == MediaStreamType.Audio
 08038                && !s.IsExternal
 08039                && (string.Equals(s.Codec, "truehd", StringComparison.OrdinalIgnoreCase)
 08040                    || string.Equals(s.Codec, "atmos", StringComparison.OrdinalIgnoreCase))
 08041                && s.Index < subtitleStream.Index);
 8042
 08043            return index + hiddenStreamsBefore;
 8044        }
 8045
 8046        public static bool IsCopyCodec(string codec)
 8047        {
 958048            return string.Equals(codec, "copy", StringComparison.OrdinalIgnoreCase);
 8049        }
 8050
 8051        private static bool ShouldEncodeSubtitle(EncodingJobInfo state)
 8052        {
 108053            return state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode
 108054                   || (state.BaseRequest.AlwaysBurnInSubtitleWhenTranscoding && !IsCopyCodec(state.OutputVideoCodec));
 8055        }
 8056
 8057        private static bool NeedsExternalSubtitleMuxing(EncodingJobInfo state)
 8058        {
 188059            return state.SubtitleStream is not null
 188060                && state.SubtitleStream.IsExternal
 188061                && (state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Embed
 188062                    || (ShouldEncodeSubtitle(state) && !state.SubtitleStream.IsTextSubtitleStream));
 8063        }
 8064
 8065        public static string GetVideoSyncOption(string videoSync, Version encoderVersion)
 8066        {
 08067            if (string.IsNullOrEmpty(videoSync))
 8068            {
 08069                return string.Empty;
 8070            }
 8071
 08072            if (encoderVersion >= new Version(5, 1))
 8073            {
 08074                if (int.TryParse(videoSync, CultureInfo.InvariantCulture, out var vsync))
 8075                {
 08076                    return vsync switch
 08077                    {
 08078                        -1 => " -fps_mode auto",
 08079                        0 => " -fps_mode passthrough",
 08080                        1 => " -fps_mode cfr",
 08081                        2 => " -fps_mode vfr",
 08082                        _ => string.Empty
 08083                    };
 8084                }
 8085
 08086                return string.Empty;
 8087            }
 8088
 8089            // -vsync is deprecated in FFmpeg 5.1 and will be removed in the future.
 08090            return $" -vsync {videoSync}";
 8091        }
 8092    }
 8093}

Methods/Properties

.ctor(MediaBrowser.Common.Configuration.IApplicationPaths,MediaBrowser.Controller.MediaEncoding.IMediaEncoder,MediaBrowser.Controller.MediaEncoding.ISubtitleEncoder,Microsoft.Extensions.Configuration.IConfiguration,MediaBrowser.Common.Configuration.IConfigurationManager,MediaBrowser.Controller.IO.IPathManager)
.cctor()
GetH264Encoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetH265Encoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetAv1Encoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetH26xOrAv1Encoder(System.String,System.String,MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetMjpegEncoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
IsVaapiSupported(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
IsVaapiFullSupported()
IsRkmppFullSupported()
IsOpenclFullSupported()
IsCudaFullSupported()
IsVulkanFullSupported()
IsVideoToolboxFullSupported()
IsSwTonemapAvailable(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
IsHwTonemapAvailable(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
IsVulkanHwTonemapAvailable(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
IsIntelVppTonemapAvailable(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
IsVideoToolboxTonemapAvailable(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
IsDeinterlaceAvailable(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
IsVideoStreamHevcRext(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetVideoEncoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetUserAgentParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetRefererParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetInputFormat(System.String)
GetDecoderFromCodec(System.String)
InferAudioCodec(System.String)
InferVideoCodec(System.String)
GetVideoProfileScore(System.String,System.String)
GetAudioEncoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetRkmppDeviceArgs(System.String)
GetVideoToolboxDeviceArgs(System.String)
GetCudaDeviceArgs(System.Int32,System.String)
GetVulkanDeviceArgs(System.Int32,System.String,System.String,System.String)
GetOpenclDeviceArgs(System.Int32,System.String,System.String,System.String)
GetD3d11vaDeviceArgs(System.Int32,System.String,System.String)
GetVaapiDeviceArgs(System.String,System.String,System.String,System.String,System.String,System.String)
GetDrmDeviceArgs(System.String,System.String)
GetQsvDeviceArgs(System.String,System.String)
GetFilterHwDeviceArgs(System.String)
GetGraphicalSubCanvasSize(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetInputVideoHwaccelArgs(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetInputArgument(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
IsH264(MediaBrowser.Model.Entities.MediaStream)
IsH265(MediaBrowser.Model.Entities.MediaStream)
IsAv1(MediaBrowser.Model.Entities.MediaStream)
IsAAC(MediaBrowser.Model.Entities.MediaStream)
IsDoviWithHdr10Bl(MediaBrowser.Model.Entities.MediaStream)
IsDovi(MediaBrowser.Model.Entities.MediaStream)
IsHdr10Plus(MediaBrowser.Model.Entities.MediaStream)
ShouldRemoveDynamicHdrMetadata(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
CanEncoderRemoveDynamicHdrMetadata(MediaBrowser.Controller.MediaEncoding.EncodingHelper/DynamicHdrMetadataRemovalPlan,MediaBrowser.Model.Entities.MediaStream)
IsDoviRemoved(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
IsHdr10PlusRemoved(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetBitStreamArgs(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Entities.MediaStreamType)
GetAudioBitStreamArguments(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.String,System.String)
GetCopiedAudioTrimBsf(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetSegmentFileExtension(System.String)
GetVideoBitrateParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.String)
GetEncoderParam(System.Nullable`1<MediaBrowser.Model.Entities.EncoderPreset>,MediaBrowser.Model.Entities.EncoderPreset,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.Boolean)
NormalizeTranscodingLevel(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.String)
GetTextSubtitlesFilter(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.Boolean,System.Boolean)
GetFramerateParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetHlsVideoKeyFrameArguments(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.String,System.Int32,System.Boolean,System.Nullable`1<System.Int32>)
GetVideoQualityParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.String,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Entities.EncoderPreset)
CanStreamCopyVideo(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Entities.MediaStream)
CanStreamCopyAudio(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Entities.MediaStream,System.Collections.Generic.IEnumerable`1<System.String>)
CanStreamCopyAudio(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Entities.MediaStream,System.Collections.Generic.IEnumerable`1<System.String>,MediaBrowser.Model.Session.TranscodeReason&)
GetAudioStreamCopyFailureReasons(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Entities.MediaStream,System.Collections.Generic.IEnumerable`1<System.String>)
GetBitDepthCompensatedBitrate(System.Int32,MediaBrowser.Model.Entities.MediaStream,System.Int32)
GetVideoBitrateParamValue(MediaBrowser.Controller.MediaEncoding.BaseEncodingJobOptions,MediaBrowser.Model.Entities.MediaStream,System.String)
GetMinBitrate(System.Int32,System.Int32)
GetVideoBitrateScaleFactor(System.String)
ScaleBitrate(System.Int32,System.String,System.String)
GetAudioBitrateParam(MediaBrowser.Controller.MediaEncoding.BaseEncodingJobOptions,MediaBrowser.Model.Entities.MediaStream,System.Nullable`1<System.Int32>)
GetAudioBitrateParam(System.Nullable`1<System.Int32>,System.String,MediaBrowser.Model.Entities.MediaStream,System.Nullable`1<System.Int32>)
GetAudioVbrModeParam(System.String,System.Int32,System.Int32)
GetAudioFilterParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetNumAudioChannelsParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Entities.MediaStream,System.String)
EnforceResolutionLimit(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetFastSeekCommandLineParameter(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetMapArgs(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetNegativeMapArgsByFilters(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.String)
GetMediaStream(System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.Entities.MediaStream>,System.Nullable`1<System.Int32>,MediaBrowser.Model.Entities.MediaStreamType,System.Boolean)
GetFixedOutputSize(System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>)
IsScaleRatioSupported(System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Double>)
GetHwScaleFilter(System.String,System.String,System.String,System.Boolean,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>)
GetGraphicalSubPreProcessFilters(System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>)
GetAlphaSrcFilter(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Single>)
GetSwScaleFilter(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<MediaBrowser.Model.Entities.Video3DFormat>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>)
GetFixedSwScaleFilter(System.Nullable`1<MediaBrowser.Model.Entities.Video3DFormat>,System.Int32,System.Int32)
GetSwDeinterlaceFilter(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetHwDeinterlaceFilter(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetHwTonemapFilter(MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String,System.Boolean)
GetLibplaceboFilter(MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.Boolean,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Boolean)
GetVideoTransposeDirection(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetSwVidFilterChain(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetNvidiaVidFilterChain(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetNvidiaVidFiltersPrefered(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetAmdVidFilterChain(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetAmdDx11VidFiltersPrefered(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetIntelVidFilterChain(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetIntelQsvDx11VidFiltersPrefered(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetIntelQsvVaapiVidFiltersPrefered(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetVaapiVidFilterChain(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetIntelVaapiFullVidFiltersPrefered(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetAmdVaapiFullVidFiltersPrefered(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetVaapiLimitedVidFiltersPrefered(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetAppleVidFilterChain(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetAppleVidFiltersPreferred(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetRkmppVidFilterChain(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetRkmppVidFiltersPrefered(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String)
GetVideoProcessingFilterParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
GetOverwriteColorPropertiesParam(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,System.Boolean)
GetInputHdrParam(System.String)
GetOutputSdrParam(System.String)
GetVideoColorBitDepth(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetHardwareVideoDecoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetHwDecoderName(MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.String,System.String,System.Int32)
GetHwaccelType(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,System.Int32,System.Boolean)
GetQsvHwVidDecoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Entities.MediaStream,System.Int32)
GetNvdecVidDecoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Entities.MediaStream,System.Int32)
GetAmfVidDecoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Entities.MediaStream,System.Int32)
GetVaapiVidDecoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Entities.MediaStream,System.Int32)
GetVideotoolboxVidDecoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Entities.MediaStream,System.Int32)
GetRkmppVidDecoder(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Entities.MediaStream,System.Int32)
GetNumberOfThreads(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
TryStreamCopy(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetFfmpegAnalyzeDurationArg(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetFfmpegProbesizeArg()
GetInputModifier(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
AttachMediaSourceInfo(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Dto.MediaSourceInfo,System.String)
ShiftAudioCodecsIfNeeded(System.Collections.Generic.List`1<System.String>,MediaBrowser.Model.Entities.MediaStream)
ShiftVideoCodecsIfNeeded(System.Collections.Generic.List`1<System.String>,MediaBrowser.Model.Configuration.EncodingOptions)
NormalizeSubtitleEmbed(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetSubtitleEmbedArguments(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetProgressiveVideoFullCommandLine(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,MediaBrowser.Model.Entities.EncoderPreset)
GetOutputFFlags(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetProgressiveVideoArguments(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String,MediaBrowser.Model.Entities.EncoderPreset)
GetProgressiveVideoAudioArguments(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions)
GetProgressiveAudioFullCommandLine(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo,MediaBrowser.Model.Configuration.EncodingOptions,System.String)
FindIndex(System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Model.Entities.MediaStream>,MediaBrowser.Model.Entities.MediaStream)
GetSubtitleStreamIndexForFfmpeg(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream)
IsCopyCodec(System.String)
ShouldEncodeSubtitle(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
NeedsExternalSubtitleMuxing(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetVideoSyncOption(System.String,System.Version)