< Summary - Jellyfin

Information
Class: MediaBrowser.Model.Dlna.StreamInfo
Assembly: MediaBrowser.Model
File(s): /srv/git/jellyfin/MediaBrowser.Model/Dlna/StreamInfo.cs
Line coverage
46%
Covered lines: 172
Uncovered lines: 198
Coverable lines: 370
Total lines: 1389
Line coverage: 46.4%
Branch coverage
38%
Covered branches: 139
Total branches: 364
Branch coverage: 38.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
get_MediaSourceId()100%22100%
get_IsDirectStream()90%1010100%
get_TargetAudioStream()50%22100%
get_TargetVideoStream()50%22100%
get_TargetAudioSampleRate()0%4260%
get_TargetAudioBitDepth()0%110100%
get_TargetVideoBitDepth()30%121071.42%
get_TargetRefFrames()0%110100%
get_TargetFramerate()0%4260%
get_TargetVideoLevel()30%121071.42%
get_TargetPacketLength()0%2040%
get_TargetVideoProfile()30%121071.42%
get_TargetVideoRangeType()0%156120%
get_TargetVideoCodecTag()0%2040%
get_TargetAudioBitrate()0%4260%
get_TargetAudioChannels()0%110100%
get_TargetAudioCodec()83.33%1212100%
get_TargetVideoCodec()66.66%121288.88%
get_TargetSize()0%7280%
get_TargetVideoBitrate()0%4260%
get_TargetTimestamp()0%4260%
get_TargetTotalBitrate()100%210%
get_IsTargetAnamorphic()0%2040%
get_IsTargetInterlaced()0%156120%
get_IsTargetAVC()0%2040%
get_TargetWidth()0%4260%
get_TargetHeight()0%4260%
get_TargetVideoStreamCount()0%620%
get_TargetAudioStreamCount()0%620%
SetOption(...)50%2275%
SetOption(...)100%11100%
GetOption(...)100%22100%
GetOption(...)100%22100%
ToUrl(...)88.77%1299885.15%
GetSubtitleProfiles(...)100%210%
GetSubtitleProfiles(...)0%702260%
AddSubtitleProfiles(...)0%7280%
GetSubtitleStreamInfo(...)0%210140%
GetTargetVideoBitDepth(...)50%2275%
GetTargetAudioBitDepth(...)0%620%
GetTargetVideoLevel(...)100%22100%
GetTargetRefFrames(...)50%2275%
GetTargetAudioChannels(...)50%9657.14%
GetMediaStreamCount(...)0%2040%

File(s)

/srv/git/jellyfin/MediaBrowser.Model/Dlna/StreamInfo.cs

#LineLine coverage
 1#pragma warning disable CA1819 // Properties should not return arrays
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Globalization;
 6using System.Linq;
 7using System.Text;
 8using Jellyfin.Data.Enums;
 9using Jellyfin.Extensions;
 10using MediaBrowser.Model.Drawing;
 11using MediaBrowser.Model.Dto;
 12using MediaBrowser.Model.Entities;
 13using MediaBrowser.Model.MediaInfo;
 14using MediaBrowser.Model.Session;
 15
 16namespace MediaBrowser.Model.Dlna;
 17
 18/// <summary>
 19/// Class holding information on a stream.
 20/// </summary>
 21public class StreamInfo
 22{
 23    /// <summary>
 24    /// Initializes a new instance of the <see cref="StreamInfo"/> class.
 25    /// </summary>
 26    public StreamInfo()
 27    {
 28        AudioCodecs = [];
 29        VideoCodecs = [];
 30        SubtitleCodecs = [];
 31        StreamOptions = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 32    }
 33
 34    /// <summary>
 35    /// Gets or sets the item id.
 36    /// </summary>
 37    /// <value>The item id.</value>
 38    public Guid ItemId { get; set; }
 39
 40    /// <summary>
 41    /// Gets or sets the play method.
 42    /// </summary>
 43    /// <value>The play method.</value>
 44    public PlayMethod PlayMethod { get; set; }
 45
 46    /// <summary>
 47    /// Gets or sets the encoding context.
 48    /// </summary>
 49    /// <value>The encoding context.</value>
 50    public EncodingContext Context { get; set; }
 51
 52    /// <summary>
 53    /// Gets or sets the media type.
 54    /// </summary>
 55    /// <value>The media type.</value>
 56    public DlnaProfileType MediaType { get; set; }
 57
 58    /// <summary>
 59    /// Gets or sets the container.
 60    /// </summary>
 61    /// <value>The container.</value>
 62    public string? Container { get; set; }
 63
 64    /// <summary>
 65    /// Gets or sets the sub protocol.
 66    /// </summary>
 67    /// <value>The sub protocol.</value>
 68    public MediaStreamProtocol SubProtocol { get; set; }
 69
 70    /// <summary>
 71    /// Gets or sets the start position ticks.
 72    /// </summary>
 73    /// <value>The start position ticks.</value>
 74    public long StartPositionTicks { get; set; }
 75
 76    /// <summary>
 77    /// Gets or sets the segment length.
 78    /// </summary>
 79    /// <value>The segment length.</value>
 80    public int? SegmentLength { get; set; }
 81
 82    /// <summary>
 83    /// Gets or sets the minimum segments count.
 84    /// </summary>
 85    /// <value>The minimum segments count.</value>
 86    public int? MinSegments { get; set; }
 87
 88    /// <summary>
 89    /// Gets or sets a value indicating whether the stream can be broken on non-keyframes.
 90    /// </summary>
 91    public bool BreakOnNonKeyFrames { get; set; }
 92
 93    /// <summary>
 94    /// Gets or sets a value indicating whether the stream requires AVC.
 95    /// </summary>
 96    public bool RequireAvc { get; set; }
 97
 98    /// <summary>
 99    /// Gets or sets a value indicating whether the stream requires AVC.
 100    /// </summary>
 101    public bool RequireNonAnamorphic { get; set; }
 102
 103    /// <summary>
 104    /// Gets or sets a value indicating whether timestamps should be copied.
 105    /// </summary>
 106    public bool CopyTimestamps { get; set; }
 107
 108    /// <summary>
 109    /// Gets or sets a value indicating whether timestamps should be copied.
 110    /// </summary>
 111    public bool EnableMpegtsM2TsMode { get; set; }
 112
 113    /// <summary>
 114    /// Gets or sets a value indicating whether the subtitle manifest is enabled.
 115    /// </summary>
 116    public bool EnableSubtitlesInManifest { get; set; }
 117
 118    /// <summary>
 119    /// Gets or sets the audio codecs.
 120    /// </summary>
 121    /// <value>The audio codecs.</value>
 122    public IReadOnlyList<string> AudioCodecs { get; set; }
 123
 124    /// <summary>
 125    /// Gets or sets the video codecs.
 126    /// </summary>
 127    /// <value>The video codecs.</value>
 128    public IReadOnlyList<string> VideoCodecs { get; set; }
 129
 130    /// <summary>
 131    /// Gets or sets the audio stream index.
 132    /// </summary>
 133    /// <value>The audio stream index.</value>
 134    public int? AudioStreamIndex { get; set; }
 135
 136    /// <summary>
 137    /// Gets or sets the video stream index.
 138    /// </summary>
 139    /// <value>The subtitle stream index.</value>
 140    public int? SubtitleStreamIndex { get; set; }
 141
 142    /// <summary>
 143    /// Gets or sets the maximum transcoding audio channels.
 144    /// </summary>
 145    /// <value>The maximum transcoding audio channels.</value>
 146    public int? TranscodingMaxAudioChannels { get; set; }
 147
 148    /// <summary>
 149    /// Gets or sets the global maximum audio channels.
 150    /// </summary>
 151    /// <value>The global maximum audio channels.</value>
 152    public int? GlobalMaxAudioChannels { get; set; }
 153
 154    /// <summary>
 155    /// Gets or sets the audio bitrate.
 156    /// </summary>
 157    /// <value>The audio bitrate.</value>
 158    public int? AudioBitrate { get; set; }
 159
 160    /// <summary>
 161    /// Gets or sets the audio sample rate.
 162    /// </summary>
 163    /// <value>The audio sample rate.</value>
 164    public int? AudioSampleRate { get; set; }
 165
 166    /// <summary>
 167    /// Gets or sets the video bitrate.
 168    /// </summary>
 169    /// <value>The video bitrate.</value>
 170    public int? VideoBitrate { get; set; }
 171
 172    /// <summary>
 173    /// Gets or sets the maximum output width.
 174    /// </summary>
 175    /// <value>The output width.</value>
 176    public int? MaxWidth { get; set; }
 177
 178    /// <summary>
 179    /// Gets or sets the maximum output height.
 180    /// </summary>
 181    /// <value>The maximum output height.</value>
 182    public int? MaxHeight { get; set; }
 183
 184    /// <summary>
 185    /// Gets or sets the maximum framerate.
 186    /// </summary>
 187    /// <value>The maximum framerate.</value>
 188    public float? MaxFramerate { get; set; }
 189
 190    /// <summary>
 191    /// Gets or sets the device profile.
 192    /// </summary>
 193    /// <value>The device profile.</value>
 194    public required DeviceProfile DeviceProfile { get; set; }
 195
 196    /// <summary>
 197    /// Gets or sets the device profile id.
 198    /// </summary>
 199    /// <value>The device profile id.</value>
 200    public string? DeviceProfileId { get; set; }
 201
 202    /// <summary>
 203    /// Gets or sets the device id.
 204    /// </summary>
 205    /// <value>The device id.</value>
 206    public string? DeviceId { get; set; }
 207
 208    /// <summary>
 209    /// Gets or sets the runtime ticks.
 210    /// </summary>
 211    /// <value>The runtime ticks.</value>
 212    public long? RunTimeTicks { get; set; }
 213
 214    /// <summary>
 215    /// Gets or sets the transcode seek info.
 216    /// </summary>
 217    /// <value>The transcode seek info.</value>
 218    public TranscodeSeekInfo TranscodeSeekInfo { get; set; }
 219
 220    /// <summary>
 221    /// Gets or sets a value indicating whether content length should be estimated.
 222    /// </summary>
 223    public bool EstimateContentLength { get; set; }
 224
 225    /// <summary>
 226    /// Gets or sets the media source info.
 227    /// </summary>
 228    /// <value>The media source info.</value>
 229    public MediaSourceInfo? MediaSource { get; set; }
 230
 231    /// <summary>
 232    /// Gets or sets the subtitle codecs.
 233    /// </summary>
 234    /// <value>The subtitle codecs.</value>
 235    public IReadOnlyList<string> SubtitleCodecs { get; set; }
 236
 237    /// <summary>
 238    /// Gets or sets the subtitle delivery method.
 239    /// </summary>
 240    /// <value>The subtitle delivery method.</value>
 241    public SubtitleDeliveryMethod SubtitleDeliveryMethod { get; set; }
 242
 243    /// <summary>
 244    /// Gets or sets the subtitle format.
 245    /// </summary>
 246    /// <value>The subtitle format.</value>
 247    public string? SubtitleFormat { get; set; }
 248
 249    /// <summary>
 250    /// Gets or sets the play session id.
 251    /// </summary>
 252    /// <value>The play session id.</value>
 253    public string? PlaySessionId { get; set; }
 254
 255    /// <summary>
 256    /// Gets or sets the transcode reasons.
 257    /// </summary>
 258    /// <value>The transcode reasons.</value>
 259    public TranscodeReason TranscodeReasons { get; set; }
 260
 261    /// <summary>
 262    /// Gets the stream options.
 263    /// </summary>
 264    /// <value>The stream options.</value>
 265    public Dictionary<string, string> StreamOptions { get; private set; }
 266
 267    /// <summary>
 268    /// Gets the media source id.
 269    /// </summary>
 270    /// <value>The media source id.</value>
 201396271    public string? MediaSourceId => MediaSource?.Id;
 272
 273    /// <summary>
 274    /// Gets or sets a value indicating whether audio VBR encoding is enabled.
 275    /// </summary>
 276    public bool EnableAudioVbrEncoding { get; set; }
 277
 278    /// <summary>
 279    /// Gets or sets a value indicating whether always burn in subtitles when transcoding.
 280    /// </summary>
 281    public bool AlwaysBurnInSubtitleWhenTranscoding { get; set; }
 282
 283    /// <summary>
 284    /// Gets a value indicating whether the stream is direct.
 285    /// </summary>
 603096286    public bool IsDirectStream => MediaSource?.VideoType is not (VideoType.Dvd or VideoType.BluRay)
 603096287        && PlayMethod is PlayMethod.DirectStream or PlayMethod.DirectPlay;
 288
 289    /// <summary>
 290    /// Gets the audio stream that will be used in the output stream.
 291    /// </summary>
 292    /// <value>The audio stream.</value>
 692293    public MediaStream? TargetAudioStream => MediaSource?.GetDefaultAudioStream(AudioStreamIndex);
 294
 295    /// <summary>
 296    /// Gets the video stream that will be used in the output stream.
 297    /// </summary>
 298    /// <value>The video stream.</value>
 1006299    public MediaStream? TargetVideoStream => MediaSource?.VideoStream;
 300
 301    /// <summary>
 302    /// Gets the audio sample rate that will be in the output stream.
 303    /// </summary>
 304    /// <value>The target audio sample rate.</value>
 305    public int? TargetAudioSampleRate
 306    {
 307        get
 308        {
 0309            var stream = TargetAudioStream;
 0310            return AudioSampleRate.HasValue && !IsDirectStream
 0311                ? AudioSampleRate
 0312                : stream?.SampleRate;
 313        }
 314    }
 315
 316    /// <summary>
 317    /// Gets the audio bit depth that will be in the output stream.
 318    /// </summary>
 319    /// <value>The target bit depth.</value>
 320    public int? TargetAudioBitDepth
 321    {
 322        get
 323        {
 0324            if (IsDirectStream)
 325            {
 0326                return TargetAudioStream?.BitDepth;
 327            }
 328
 0329            var targetAudioCodecs = TargetAudioCodec;
 0330            var audioCodec = targetAudioCodecs.Count == 0 ? null : targetAudioCodecs[0];
 0331            if (!string.IsNullOrEmpty(audioCodec))
 332            {
 0333                return GetTargetAudioBitDepth(audioCodec);
 334            }
 335
 0336            return TargetAudioStream?.BitDepth;
 337        }
 338    }
 339
 340    /// <summary>
 341    /// Gets the video bit depth that will be in the output stream.
 342    /// </summary>
 343    /// <value>The target video bit depth.</value>
 344    public int? TargetVideoBitDepth
 345    {
 346        get
 347        {
 96348            if (IsDirectStream)
 349            {
 0350                return TargetVideoStream?.BitDepth;
 351            }
 352
 96353            var targetVideoCodecs = TargetVideoCodec;
 96354            var videoCodec = targetVideoCodecs.Count == 0 ? null : targetVideoCodecs[0];
 96355            if (!string.IsNullOrEmpty(videoCodec))
 356            {
 96357                return GetTargetVideoBitDepth(videoCodec);
 358            }
 359
 0360            return TargetVideoStream?.BitDepth;
 361        }
 362    }
 363
 364    /// <summary>
 365    /// Gets the target reference frames that will be in the output stream.
 366    /// </summary>
 367    /// <value>The target reference frames.</value>
 368    public int? TargetRefFrames
 369    {
 370        get
 371        {
 0372            if (IsDirectStream)
 373            {
 0374                return TargetVideoStream?.RefFrames;
 375            }
 376
 0377            var targetVideoCodecs = TargetVideoCodec;
 0378            var videoCodec = targetVideoCodecs.Count == 0 ? null : targetVideoCodecs[0];
 0379            if (!string.IsNullOrEmpty(videoCodec))
 380            {
 0381                return GetTargetRefFrames(videoCodec);
 382            }
 383
 0384            return TargetVideoStream?.RefFrames;
 385        }
 386    }
 387
 388    /// <summary>
 389    /// Gets the target framerate that will be in the output stream.
 390    /// </summary>
 391    /// <value>The target framerate.</value>
 392    public float? TargetFramerate
 393    {
 394        get
 395        {
 0396            var stream = TargetVideoStream;
 0397            return MaxFramerate.HasValue && !IsDirectStream
 0398                ? MaxFramerate
 0399                : stream?.ReferenceFrameRate;
 400        }
 401    }
 402
 403    /// <summary>
 404    /// Gets the target video level that will be in the output stream.
 405    /// </summary>
 406    /// <value>The target video level.</value>
 407    public double? TargetVideoLevel
 408    {
 409        get
 410        {
 96411            if (IsDirectStream)
 412            {
 0413                return TargetVideoStream?.Level;
 414            }
 415
 96416            var targetVideoCodecs = TargetVideoCodec;
 96417            var videoCodec = targetVideoCodecs.Count == 0 ? null : targetVideoCodecs[0];
 96418            if (!string.IsNullOrEmpty(videoCodec))
 419            {
 96420                return GetTargetVideoLevel(videoCodec);
 421            }
 422
 0423            return TargetVideoStream?.Level;
 424        }
 425    }
 426
 427    /// <summary>
 428    /// Gets the target packet length that will be in the output stream.
 429    /// </summary>
 430    /// <value>The target packet length.</value>
 431    public int? TargetPacketLength
 432    {
 433        get
 434        {
 0435            var stream = TargetVideoStream;
 0436            return !IsDirectStream
 0437                ? null
 0438                : stream?.PacketLength;
 439        }
 440    }
 441
 442    /// <summary>
 443    /// Gets the target video profile that will be in the output stream.
 444    /// </summary>
 445    /// <value>The target video profile.</value>
 446    public string? TargetVideoProfile
 447    {
 448        get
 449        {
 96450            if (IsDirectStream)
 451            {
 0452                return TargetVideoStream?.Profile;
 453            }
 454
 96455            var targetVideoCodecs = TargetVideoCodec;
 96456            var videoCodec = targetVideoCodecs.Count == 0 ? null : targetVideoCodecs[0];
 96457            if (!string.IsNullOrEmpty(videoCodec))
 458            {
 96459                return GetOption(videoCodec, "profile");
 460            }
 461
 0462            return TargetVideoStream?.Profile;
 463        }
 464    }
 465
 466    /// <summary>
 467    /// Gets the target video range type that will be in the output stream.
 468    /// </summary>
 469    /// <value>The video range type.</value>
 470    public VideoRangeType TargetVideoRangeType
 471    {
 472        get
 473        {
 0474            if (IsDirectStream)
 475            {
 0476                return TargetVideoStream?.VideoRangeType ?? VideoRangeType.Unknown;
 477            }
 478
 0479            var targetVideoCodecs = TargetVideoCodec;
 0480            var videoCodec = targetVideoCodecs.Count == 0 ? null : targetVideoCodecs[0];
 0481            if (!string.IsNullOrEmpty(videoCodec)
 0482                && Enum.TryParse(GetOption(videoCodec, "rangetype"), true, out VideoRangeType videoRangeType))
 483            {
 0484                return videoRangeType;
 485            }
 486
 0487            return TargetVideoStream?.VideoRangeType ?? VideoRangeType.Unknown;
 488        }
 489    }
 490
 491    /// <summary>
 492    /// Gets the target video codec tag.
 493    /// </summary>
 494    /// <value>The video codec tag.</value>
 495    public string? TargetVideoCodecTag
 496    {
 497        get
 498        {
 0499            var stream = TargetVideoStream;
 0500            return !IsDirectStream
 0501                ? null
 0502                : stream?.CodecTag;
 503        }
 504    }
 505
 506    /// <summary>
 507    /// Gets the audio bitrate that will be in the output stream.
 508    /// </summary>
 509    /// <value>The audio bitrate.</value>
 510    public int? TargetAudioBitrate
 511    {
 512        get
 513        {
 0514            var stream = TargetAudioStream;
 0515            return AudioBitrate.HasValue && !IsDirectStream
 0516                ? AudioBitrate
 0517                : stream?.BitRate;
 518        }
 519    }
 520
 521    /// <summary>
 522    /// Gets the amount of audio channels that will be in the output stream.
 523    /// </summary>
 524    /// <value>The target audio channels.</value>
 525    public int? TargetAudioChannels
 526    {
 527        get
 528        {
 0529            if (IsDirectStream)
 530            {
 0531                return TargetAudioStream?.Channels;
 532            }
 533
 0534            var targetAudioCodecs = TargetAudioCodec;
 0535            var codec = targetAudioCodecs.Count == 0 ? null : targetAudioCodecs[0];
 0536            if (!string.IsNullOrEmpty(codec))
 537            {
 0538                return GetTargetRefFrames(codec);
 539            }
 540
 0541            return TargetAudioStream?.Channels;
 542        }
 543    }
 544
 545    /// <summary>
 546    /// Gets the audio codec that will be in the output stream.
 547    /// </summary>
 548    /// <value>The audio codec.</value>
 549    public IReadOnlyList<string> TargetAudioCodec
 550    {
 551        get
 552        {
 394553            var stream = TargetAudioStream;
 554
 394555            string? inputCodec = stream?.Codec;
 556
 394557            if (IsDirectStream)
 558            {
 248559                return string.IsNullOrEmpty(inputCodec) ? [] : [inputCodec];
 560            }
 561
 784562            foreach (string codec in AudioCodecs)
 563            {
 286564                if (string.Equals(codec, inputCodec, StringComparison.OrdinalIgnoreCase))
 565                {
 80566                    return string.IsNullOrEmpty(codec) ? [] : [codec];
 567                }
 568            }
 569
 66570            return AudioCodecs;
 80571        }
 572    }
 573
 574    /// <summary>
 575    /// Gets the video codec that will be in the output stream.
 576    /// </summary>
 577    /// <value>The target video codec.</value>
 578    public IReadOnlyList<string> TargetVideoCodec
 579    {
 580        get
 581        {
 728582            var stream = TargetVideoStream;
 583
 728584            string? inputCodec = stream?.Codec;
 585
 728586            if (IsDirectStream)
 587            {
 248588                return string.IsNullOrEmpty(inputCodec) ? [] : [inputCodec];
 589            }
 590
 2280591            foreach (string codec in VideoCodecs)
 592            {
 900593                if (string.Equals(codec, inputCodec, StringComparison.OrdinalIgnoreCase))
 594                {
 480595                    return string.IsNullOrEmpty(codec) ? [] : [codec];
 596                }
 597            }
 598
 0599            return VideoCodecs;
 480600        }
 601    }
 602
 603    /// <summary>
 604    /// Gets the target size of the output stream.
 605    /// </summary>
 606    /// <value>The target size.</value>
 607    public long? TargetSize
 608    {
 609        get
 610        {
 0611            if (IsDirectStream)
 612            {
 0613                return MediaSource?.Size;
 614            }
 615
 0616            if (RunTimeTicks.HasValue)
 617            {
 0618                int? totalBitrate = TargetTotalBitrate;
 619
 0620                double totalSeconds = RunTimeTicks.Value;
 621                // Convert to ms
 0622                totalSeconds /= 10000;
 623                // Convert to seconds
 0624                totalSeconds /= 1000;
 625
 0626                return totalBitrate.HasValue ?
 0627                    Convert.ToInt64(totalBitrate.Value * totalSeconds) :
 0628                    null;
 629            }
 630
 0631            return null;
 632        }
 633    }
 634
 635    /// <summary>
 636    /// Gets the target video bitrate of the output stream.
 637    /// </summary>
 638    /// <value>The video bitrate.</value>
 639    public int? TargetVideoBitrate
 640    {
 641        get
 642        {
 0643            var stream = TargetVideoStream;
 644
 0645            return VideoBitrate.HasValue && !IsDirectStream
 0646                ? VideoBitrate
 0647                : stream?.BitRate;
 648        }
 649    }
 650
 651    /// <summary>
 652    /// Gets the target timestamp of the output stream.
 653    /// </summary>
 654    /// <value>The target timestamp.</value>
 655    public TransportStreamTimestamp TargetTimestamp
 656    {
 657        get
 658        {
 0659            var defaultValue = string.Equals(Container, "m2ts", StringComparison.OrdinalIgnoreCase)
 0660                ? TransportStreamTimestamp.Valid
 0661                : TransportStreamTimestamp.None;
 662
 0663            return !IsDirectStream
 0664                ? defaultValue
 0665                : MediaSource is null ? defaultValue : MediaSource.Timestamp ?? TransportStreamTimestamp.None;
 666        }
 667    }
 668
 669    /// <summary>
 670    /// Gets the target total bitrate of the output stream.
 671    /// </summary>
 672    /// <value>The target total bitrate.</value>
 0673    public int? TargetTotalBitrate => (TargetAudioBitrate ?? 0) + (TargetVideoBitrate ?? 0);
 674
 675    /// <summary>
 676    /// Gets a value indicating whether the output stream is anamorphic.
 677    /// </summary>
 678    public bool? IsTargetAnamorphic
 679    {
 680        get
 681        {
 0682            if (IsDirectStream)
 683            {
 0684                return TargetVideoStream?.IsAnamorphic;
 685            }
 686
 0687            return false;
 688        }
 689    }
 690
 691    /// <summary>
 692    /// Gets a value indicating whether the output stream is interlaced.
 693    /// </summary>
 694    public bool? IsTargetInterlaced
 695    {
 696        get
 697        {
 0698            if (IsDirectStream)
 699            {
 0700                return TargetVideoStream?.IsInterlaced;
 701            }
 702
 0703            var targetVideoCodecs = TargetVideoCodec;
 0704            var videoCodec = targetVideoCodecs.Count == 0 ? null : targetVideoCodecs[0];
 0705            if (!string.IsNullOrEmpty(videoCodec))
 706            {
 0707                if (string.Equals(GetOption(videoCodec, "deinterlace"), "true", StringComparison.OrdinalIgnoreCase))
 708                {
 0709                    return false;
 710                }
 711            }
 712
 0713            return TargetVideoStream?.IsInterlaced;
 714        }
 715    }
 716
 717    /// <summary>
 718    /// Gets a value indicating whether the output stream is AVC.
 719    /// </summary>
 720    public bool? IsTargetAVC
 721    {
 722        get
 723        {
 0724            if (IsDirectStream)
 725            {
 0726                return TargetVideoStream?.IsAVC;
 727            }
 728
 0729            return true;
 730        }
 731    }
 732
 733    /// <summary>
 734    /// Gets the target width of the output stream.
 735    /// </summary>
 736    /// <value>The target width.</value>
 737    public int? TargetWidth
 738    {
 739        get
 740        {
 0741            var videoStream = TargetVideoStream;
 742
 0743            if (videoStream is not null && videoStream.Width.HasValue && videoStream.Height.HasValue)
 744            {
 0745                ImageDimensions size = new ImageDimensions(videoStream.Width.Value, videoStream.Height.Value);
 746
 0747                size = DrawingUtils.Resize(size, 0, 0, MaxWidth ?? 0, MaxHeight ?? 0);
 748
 0749                return size.Width;
 750            }
 751
 0752            return MaxWidth;
 753        }
 754    }
 755
 756    /// <summary>
 757    /// Gets the target height of the output stream.
 758    /// </summary>
 759    /// <value>The target height.</value>
 760    public int? TargetHeight
 761    {
 762        get
 763        {
 0764            var videoStream = TargetVideoStream;
 765
 0766            if (videoStream is not null && videoStream.Width.HasValue && videoStream.Height.HasValue)
 767            {
 0768                ImageDimensions size = new ImageDimensions(videoStream.Width.Value, videoStream.Height.Value);
 769
 0770                size = DrawingUtils.Resize(size, 0, 0, MaxWidth ?? 0, MaxHeight ?? 0);
 771
 0772                return size.Height;
 773            }
 774
 0775            return MaxHeight;
 776        }
 777    }
 778
 779    /// <summary>
 780    /// Gets the target video stream count of the output stream.
 781    /// </summary>
 782    /// <value>The target video stream count.</value>
 783    public int? TargetVideoStreamCount
 784    {
 785        get
 786        {
 0787            if (IsDirectStream)
 788            {
 0789                return GetMediaStreamCount(MediaStreamType.Video, int.MaxValue);
 790            }
 791
 0792            return GetMediaStreamCount(MediaStreamType.Video, 1);
 793        }
 794    }
 795
 796    /// <summary>
 797    /// Gets the target audio stream count of the output stream.
 798    /// </summary>
 799    /// <value>The target audio stream count.</value>
 800    public int? TargetAudioStreamCount
 801    {
 802        get
 803        {
 0804            if (IsDirectStream)
 805            {
 0806                return GetMediaStreamCount(MediaStreamType.Audio, int.MaxValue);
 807            }
 808
 0809            return GetMediaStreamCount(MediaStreamType.Audio, 1);
 810        }
 811    }
 812
 813    /// <summary>
 814    /// Sets a stream option.
 815    /// </summary>
 816    /// <param name="qualifier">The qualifier.</param>
 817    /// <param name="name">The name.</param>
 818    /// <param name="value">The value.</param>
 819    public void SetOption(string? qualifier, string name, string value)
 820    {
 1388821        if (string.IsNullOrEmpty(qualifier))
 822        {
 0823            SetOption(name, value);
 824        }
 825        else
 826        {
 1388827            SetOption(qualifier + "-" + name, value);
 828        }
 1388829    }
 830
 831    /// <summary>
 832    /// Sets a stream option.
 833    /// </summary>
 834    /// <param name="name">The name.</param>
 835    /// <param name="value">The value.</param>
 836    public void SetOption(string name, string value)
 837    {
 1388838        StreamOptions[name] = value;
 1388839    }
 840
 841    /// <summary>
 842    /// Gets a stream option.
 843    /// </summary>
 844    /// <param name="qualifier">The qualifier.</param>
 845    /// <param name="name">The name.</param>
 846    /// <returns>The value.</returns>
 847    public string? GetOption(string? qualifier, string name)
 848    {
 1170849        var value = GetOption(qualifier + "-" + name);
 850
 1170851        if (string.IsNullOrEmpty(value))
 852        {
 722853            value = GetOption(name);
 854        }
 855
 1170856        return value;
 857    }
 858
 859    /// <summary>
 860    /// Gets a stream option.
 861    /// </summary>
 862    /// <param name="name">The name.</param>
 863    /// <returns>The value.</returns>
 864    public string? GetOption(string name)
 865    {
 1892866        if (StreamOptions.TryGetValue(name, out var value))
 867        {
 448868            return value;
 869        }
 870
 1444871        return null;
 872    }
 873
 874    /// <summary>
 875    /// Returns this output stream URL for this class.
 876    /// </summary>
 877    /// <param name="baseUrl">The base Url.</param>
 878    /// <param name="accessToken">The access Token.</param>
 879    /// <param name="query">Optional extra query.</param>
 880    /// <returns>A querystring representation of this object.</returns>
 881    public string ToUrl(string? baseUrl, string? accessToken, string? query)
 882    {
 100559883        var sb = new StringBuilder();
 100559884        if (!string.IsNullOrEmpty(baseUrl))
 885        {
 100559886            sb.Append(baseUrl.TrimEnd('/'));
 887        }
 888
 100559889        if (MediaType == DlnaProfileType.Audio)
 890        {
 100001891            sb.Append("/audio/");
 892        }
 893        else
 894        {
 558895            sb.Append("/videos/");
 896        }
 897
 100559898        sb.Append(ItemId);
 899
 100559900        if (SubProtocol == MediaStreamProtocol.hls)
 901        {
 264902            sb.Append("/master.m3u8?");
 903        }
 904        else
 905        {
 100295906            sb.Append("/stream");
 907
 100295908            if (!string.IsNullOrEmpty(Container))
 909            {
 100276910                sb.Append('.');
 100276911                sb.Append(Container);
 912            }
 913
 100295914            sb.Append('?');
 915        }
 916
 100559917        if (!string.IsNullOrEmpty(DeviceProfileId))
 918        {
 100000919            sb.Append("&DeviceProfileId=");
 100000920            sb.Append(DeviceProfileId);
 921        }
 922
 100559923        if (!string.IsNullOrEmpty(DeviceId))
 924        {
 100278925            sb.Append("&DeviceId=");
 100278926            sb.Append(DeviceId);
 927        }
 928
 100559929        if (!string.IsNullOrEmpty(MediaSourceId))
 930        {
 556931            sb.Append("&MediaSourceId=");
 556932            sb.Append(MediaSourceId);
 933        }
 934
 935        // default true so don't store.
 100559936        if (IsDirectStream)
 937        {
 100248938            sb.Append("&Static=true");
 939        }
 940
 100559941        if (VideoCodecs.Count != 0)
 942        {
 540943            sb.Append("&VideoCodec=");
 540944            sb.AppendJoin(',', VideoCodecs);
 945        }
 946
 100559947        if (AudioCodecs.Count != 0)
 948        {
 540949            sb.Append("&AudioCodec=");
 540950            sb.AppendJoin(',', AudioCodecs);
 951        }
 952
 100559953        if (AudioStreamIndex.HasValue)
 954        {
 554955            sb.Append("&AudioStreamIndex=");
 554956            sb.Append(AudioStreamIndex.Value.ToString(CultureInfo.InvariantCulture));
 957        }
 958
 100559959        if (SubtitleStreamIndex.HasValue && (AlwaysBurnInSubtitleWhenTranscoding || SubtitleDeliveryMethod != SubtitleDe
 960        {
 16961            sb.Append("&SubtitleStreamIndex=");
 16962            sb.Append(SubtitleStreamIndex.Value.ToString(CultureInfo.InvariantCulture));
 963        }
 964
 100559965        if (VideoBitrate.HasValue)
 966        {
 292967            sb.Append("&VideoBitrate=");
 292968            sb.Append(VideoBitrate.Value.ToString(CultureInfo.InvariantCulture));
 969        }
 970
 100559971        if (AudioBitrate.HasValue)
 972        {
 292973            sb.Append("&AudioBitrate=");
 292974            sb.Append(AudioBitrate.Value.ToString(CultureInfo.InvariantCulture));
 975        }
 976
 100559977        if (AudioSampleRate.HasValue)
 978        {
 110979            sb.Append("&AudioSampleRate=");
 110980            sb.Append(AudioSampleRate.Value.ToString(CultureInfo.InvariantCulture));
 981        }
 982
 100559983        if (MaxFramerate.HasValue)
 984        {
 290985            sb.Append("&MaxFramerate=");
 290986            sb.Append(MaxFramerate.Value.ToString(CultureInfo.InvariantCulture));
 987        }
 988
 100559989        if (MaxWidth.HasValue)
 990        {
 8991            sb.Append("&MaxWidth=");
 8992            sb.Append(MaxWidth.Value.ToString(CultureInfo.InvariantCulture));
 993        }
 994
 100559995        if (MaxHeight.HasValue)
 996        {
 0997            sb.Append("&MaxHeight=");
 0998            sb.Append(MaxHeight.Value.ToString(CultureInfo.InvariantCulture));
 999        }
 1000
 1005591001        if (SubProtocol == MediaStreamProtocol.hls)
 1002        {
 2641003            if (!string.IsNullOrEmpty(Container))
 1004            {
 2641005                sb.Append("&SegmentContainer=");
 2641006                sb.Append(Container);
 1007            }
 1008
 2641009            if (SegmentLength.HasValue)
 1010            {
 01011                sb.Append("&SegmentLength=");
 01012                sb.Append(SegmentLength.Value.ToString(CultureInfo.InvariantCulture));
 1013            }
 1014
 2641015            if (MinSegments.HasValue)
 1016            {
 2041017                sb.Append("&MinSegments=");
 2041018                sb.Append(MinSegments.Value.ToString(CultureInfo.InvariantCulture));
 1019            }
 1020
 2641021            sb.Append("&BreakOnNonKeyFrames=");
 2641022            sb.Append(BreakOnNonKeyFrames.ToString(CultureInfo.InvariantCulture));
 1023        }
 1024        else
 1025        {
 1002951026            if (StartPositionTicks != 0)
 1027            {
 1000001028                sb.Append("&StartTimeTicks=");
 1000001029                sb.Append(StartPositionTicks.ToString(CultureInfo.InvariantCulture));
 1030            }
 1031        }
 1032
 1005591033        if (!string.IsNullOrEmpty(PlaySessionId))
 1034        {
 1000001035            sb.Append("&PlaySessionId=");
 1000001036            sb.Append(PlaySessionId);
 1037        }
 1038
 1005591039        if (!string.IsNullOrEmpty(accessToken))
 1040        {
 1005591041            sb.Append("&ApiKey=");
 1005591042            sb.Append(accessToken);
 1043        }
 1044
 1005591045        var liveStreamId = MediaSource?.LiveStreamId;
 1005591046        if (!string.IsNullOrEmpty(liveStreamId))
 1047        {
 01048            sb.Append("&LiveStreamId=");
 01049            sb.Append(liveStreamId);
 1050        }
 1051
 1005591052        if (!IsDirectStream)
 1053        {
 3111054            if (RequireNonAnamorphic)
 1055            {
 01056                sb.Append("&RequireNonAnamorphic=");
 01057                sb.Append(RequireNonAnamorphic.ToString(CultureInfo.InvariantCulture));
 1058            }
 1059
 3111060            if (TranscodingMaxAudioChannels.HasValue)
 1061            {
 2661062                sb.Append("&TranscodingMaxAudioChannels=");
 2661063                sb.Append(TranscodingMaxAudioChannels.Value.ToString(CultureInfo.InvariantCulture));
 1064            }
 1065
 3111066            if (EnableSubtitlesInManifest)
 1067            {
 01068                sb.Append("&EnableSubtitlesInManifest=");
 01069                sb.Append(EnableSubtitlesInManifest.ToString(CultureInfo.InvariantCulture));
 1070            }
 1071
 3111072            if (EnableMpegtsM2TsMode)
 1073            {
 01074                sb.Append("&EnableMpegtsM2TsMode=");
 01075                sb.Append(EnableMpegtsM2TsMode.ToString(CultureInfo.InvariantCulture));
 1076            }
 1077
 3111078            if (EstimateContentLength)
 1079            {
 01080                sb.Append("&EstimateContentLength=");
 01081                sb.Append(EstimateContentLength.ToString(CultureInfo.InvariantCulture));
 1082            }
 1083
 3111084            if (TranscodeSeekInfo != TranscodeSeekInfo.Auto)
 1085            {
 01086                sb.Append("&TranscodeSeekInfo=");
 01087                sb.Append(TranscodeSeekInfo.ToString());
 1088            }
 1089
 3111090            if (CopyTimestamps)
 1091            {
 241092                sb.Append("&CopyTimestamps=");
 241093                sb.Append(CopyTimestamps.ToString(CultureInfo.InvariantCulture));
 1094            }
 1095
 3111096            sb.Append("&RequireAvc=");
 3111097            sb.Append(RequireAvc.ToString(CultureInfo.InvariantCulture).ToLowerInvariant());
 1098
 3111099            sb.Append("&EnableAudioVbrEncoding=");
 3111100            sb.Append(EnableAudioVbrEncoding.ToString(CultureInfo.InvariantCulture).ToLowerInvariant());
 1101        }
 1102
 1005591103        var etag = MediaSource?.ETag;
 1005591104        if (!string.IsNullOrEmpty(etag))
 1105        {
 5561106            sb.Append("&Tag=");
 5561107            sb.Append(etag);
 1108        }
 1109
 1005591110        if (SubtitleStreamIndex.HasValue && SubtitleDeliveryMethod != SubtitleDeliveryMethod.External)
 1111        {
 521112            sb.Append("&SubtitleMethod=");
 521113            sb.Append(SubtitleDeliveryMethod);
 1114        }
 1115
 1005591116        if (SubtitleStreamIndex.HasValue && SubtitleDeliveryMethod == SubtitleDeliveryMethod.Embed && SubtitleCodecs.Cou
 1117        {
 01118            sb.Append("&SubtitleCodec=");
 01119            sb.AppendJoin(',', SubtitleCodecs);
 1120        }
 1121
 2060301122        foreach (var pair in StreamOptions)
 1123        {
 1124            // Strip spaces to avoid having to encode h264 profile names
 24561125            sb.Append('&');
 24561126            sb.Append(pair.Key);
 24561127            sb.Append('=');
 24561128            sb.Append(pair.Value.Replace(" ", string.Empty, StringComparison.Ordinal));
 1129        }
 1130
 1005591131        var transcodeReasonsValues = TranscodeReasons.GetUniqueFlags().ToArray();
 1005591132        if (!IsDirectStream && transcodeReasonsValues.Length > 0)
 1133        {
 3081134            sb.Append("&TranscodeReasons=");
 3081135            sb.AppendJoin(',', transcodeReasonsValues);
 1136        }
 1137
 1005591138        if (!string.IsNullOrEmpty(query))
 1139        {
 01140            sb.Append(query);
 1141        }
 1142
 1005591143        return sb.ToString();
 1144    }
 1145
 1146    /// <summary>
 1147    /// Gets the subtitle profiles.
 1148    /// </summary>
 1149    /// <param name="transcoderSupport">The transcoder support.</param>
 1150    /// <param name="includeSelectedTrackOnly">If only the selected track should be included.</param>
 1151    /// <param name="baseUrl">The base URL.</param>
 1152    /// <param name="accessToken">The access token.</param>
 1153    /// <returns>The <see cref="SubtitleStreamInfo"/> of the profiles.</returns>
 1154    public IEnumerable<SubtitleStreamInfo> GetSubtitleProfiles(ITranscoderSupport transcoderSupport, bool includeSelecte
 1155    {
 01156        return GetSubtitleProfiles(transcoderSupport, includeSelectedTrackOnly, false, baseUrl, accessToken);
 1157    }
 1158
 1159    /// <summary>
 1160    /// Gets the subtitle profiles.
 1161    /// </summary>
 1162    /// <param name="transcoderSupport">The transcoder support.</param>
 1163    /// <param name="includeSelectedTrackOnly">If only the selected track should be included.</param>
 1164    /// <param name="enableAllProfiles">If all profiles are enabled.</param>
 1165    /// <param name="baseUrl">The base URL.</param>
 1166    /// <param name="accessToken">The access token.</param>
 1167    /// <returns>The <see cref="SubtitleStreamInfo"/> of the profiles.</returns>
 1168    public IEnumerable<SubtitleStreamInfo> GetSubtitleProfiles(ITranscoderSupport transcoderSupport, bool includeSelecte
 1169    {
 01170        if (MediaSource is null)
 1171        {
 01172            return [];
 1173        }
 1174
 01175        List<SubtitleStreamInfo> list = [];
 1176
 1177        // HLS will preserve timestamps so we can just grab the full subtitle stream
 01178        long startPositionTicks = SubProtocol == MediaStreamProtocol.hls
 01179            ? 0
 01180            : (PlayMethod == PlayMethod.Transcode && !CopyTimestamps ? StartPositionTicks : 0);
 1181
 1182        // First add the selected track
 01183        if (SubtitleStreamIndex.HasValue)
 1184        {
 01185            foreach (var stream in MediaSource.MediaStreams)
 1186            {
 01187                if (stream.Type == MediaStreamType.Subtitle && stream.Index == SubtitleStreamIndex.Value)
 1188                {
 01189                    AddSubtitleProfiles(list, stream, transcoderSupport, enableAllProfiles, baseUrl, accessToken, startP
 1190                }
 1191            }
 1192        }
 1193
 01194        if (!includeSelectedTrackOnly)
 1195        {
 01196            foreach (var stream in MediaSource.MediaStreams)
 1197            {
 01198                if (stream.Type == MediaStreamType.Subtitle && (!SubtitleStreamIndex.HasValue || stream.Index != Subtitl
 1199                {
 01200                    AddSubtitleProfiles(list, stream, transcoderSupport, enableAllProfiles, baseUrl, accessToken, startP
 1201                }
 1202            }
 1203        }
 1204
 01205        return list;
 1206    }
 1207
 1208    private void AddSubtitleProfiles(List<SubtitleStreamInfo> list, MediaStream stream, ITranscoderSupport transcoderSup
 1209    {
 01210        if (enableAllProfiles)
 1211        {
 01212            foreach (var profile in DeviceProfile.SubtitleProfiles)
 1213            {
 01214                var info = GetSubtitleStreamInfo(stream, baseUrl, accessToken, startPositionTicks, new[] { profile }, tr
 01215                if (info is not null)
 1216                {
 01217                    list.Add(info);
 1218                }
 1219            }
 1220        }
 1221        else
 1222        {
 01223            var info = GetSubtitleStreamInfo(stream, baseUrl, accessToken, startPositionTicks, DeviceProfile.SubtitlePro
 01224            if (info is not null)
 1225            {
 01226                list.Add(info);
 1227            }
 1228        }
 01229    }
 1230
 1231    private SubtitleStreamInfo? GetSubtitleStreamInfo(MediaStream stream, string baseUrl, string? accessToken, long star
 1232    {
 01233        if (MediaSource is null)
 1234        {
 01235            return null;
 1236        }
 1237
 01238        var subtitleProfile = StreamBuilder.GetSubtitleProfile(MediaSource, stream, subtitleProfiles, PlayMethod, transc
 01239        var info = new SubtitleStreamInfo
 01240        {
 01241            IsForced = stream.IsForced,
 01242            Language = stream.Language,
 01243            Name = stream.Language ?? "Unknown",
 01244            Format = subtitleProfile.Format,
 01245            Index = stream.Index,
 01246            DeliveryMethod = subtitleProfile.Method,
 01247            DisplayTitle = stream.DisplayTitle
 01248        };
 1249
 01250        if (info.DeliveryMethod == SubtitleDeliveryMethod.External)
 1251        {
 01252            if (MediaSource.Protocol == MediaProtocol.File || !string.Equals(stream.Codec, subtitleProfile.Format, Strin
 1253            {
 01254                info.Url = string.Format(
 01255                    CultureInfo.InvariantCulture,
 01256                    "{0}/Videos/{1}/{2}/Subtitles/{3}/{4}/Stream.{5}",
 01257                    baseUrl,
 01258                    ItemId,
 01259                    MediaSourceId,
 01260                    stream.Index.ToString(CultureInfo.InvariantCulture),
 01261                    startPositionTicks.ToString(CultureInfo.InvariantCulture),
 01262                    subtitleProfile.Format);
 1263
 01264                if (!string.IsNullOrEmpty(accessToken))
 1265                {
 01266                    info.Url += "?ApiKey=" + accessToken;
 1267                }
 1268
 01269                info.IsExternalUrl = false;
 1270            }
 1271            else
 1272            {
 01273                info.Url = stream.Path;
 01274                info.IsExternalUrl = true;
 1275            }
 1276        }
 1277
 01278        return info;
 1279    }
 1280
 1281    /// <summary>
 1282    /// Gets the target video bit depth.
 1283    /// </summary>
 1284    /// <param name="codec">The codec.</param>
 1285    /// <returns>The target video bit depth.</returns>
 1286    public int? GetTargetVideoBitDepth(string? codec)
 1287    {
 961288        var value = GetOption(codec, "videobitdepth");
 1289
 961290        if (int.TryParse(value, CultureInfo.InvariantCulture, out var result))
 1291        {
 961292            return result;
 1293        }
 1294
 01295        return null;
 1296    }
 1297
 1298    /// <summary>
 1299    /// Gets the target audio bit depth.
 1300    /// </summary>
 1301    /// <param name="codec">The codec.</param>
 1302    /// <returns>The target audio bit depth.</returns>
 1303    public int? GetTargetAudioBitDepth(string? codec)
 1304    {
 01305        var value = GetOption(codec, "audiobitdepth");
 1306
 01307        if (int.TryParse(value, CultureInfo.InvariantCulture, out var result))
 1308        {
 01309            return result;
 1310        }
 1311
 01312        return null;
 1313    }
 1314
 1315    /// <summary>
 1316    /// Gets the target video level.
 1317    /// </summary>
 1318    /// <param name="codec">The codec.</param>
 1319    /// <returns>The target video level.</returns>
 1320    public double? GetTargetVideoLevel(string? codec)
 1321    {
 3081322        var value = GetOption(codec, "level");
 1323
 3081324        if (double.TryParse(value, CultureInfo.InvariantCulture, out var result))
 1325        {
 1701326            return result;
 1327        }
 1328
 1381329        return null;
 1330    }
 1331
 1332    /// <summary>
 1333    /// Gets the target reference frames.
 1334    /// </summary>
 1335    /// <param name="codec">The codec.</param>
 1336    /// <returns>The target reference frames.</returns>
 1337    public int? GetTargetRefFrames(string? codec)
 1338    {
 21339        var value = GetOption(codec, "maxrefframes");
 1340
 21341        if (int.TryParse(value, CultureInfo.InvariantCulture, out var result))
 1342        {
 01343            return result;
 1344        }
 1345
 21346        return null;
 1347    }
 1348
 1349    /// <summary>
 1350    /// Gets the target audio channels.
 1351    /// </summary>
 1352    /// <param name="codec">The codec.</param>
 1353    /// <returns>The target audio channels.</returns>
 1354    public int? GetTargetAudioChannels(string? codec)
 1355    {
 1741356        var defaultValue = GlobalMaxAudioChannels ?? TranscodingMaxAudioChannels;
 1357
 1741358        var value = GetOption(codec, "audiochannels");
 1741359        if (string.IsNullOrEmpty(value))
 1360        {
 1741361            return defaultValue;
 1362        }
 1363
 01364        if (int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
 1365        {
 01366            return Math.Min(result, defaultValue ?? result);
 1367        }
 1368
 01369        return defaultValue;
 1370    }
 1371
 1372    /// <summary>
 1373    /// Gets the media stream count.
 1374    /// </summary>
 1375    /// <param name="type">The type.</param>
 1376    /// <param name="limit">The limit.</param>
 1377    /// <returns>The media stream count.</returns>
 1378    private int? GetMediaStreamCount(MediaStreamType type, int limit)
 1379    {
 01380        var count = MediaSource?.GetStreamCount(type);
 1381
 01382        if (count.HasValue)
 1383        {
 01384            count = Math.Min(count.Value, limit);
 1385        }
 1386
 01387        return count;
 1388    }
 1389}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:22 AM
GitHub | reportgenerator.io

Methods/Properties

get_MediaSourceId()
get_IsDirectStream()
get_TargetAudioStream()
get_TargetVideoStream()
get_TargetAudioSampleRate()
get_TargetAudioBitDepth()
get_TargetVideoBitDepth()
get_TargetRefFrames()
get_TargetFramerate()
get_TargetVideoLevel()
get_TargetPacketLength()
get_TargetVideoProfile()
get_TargetVideoRangeType()
get_TargetVideoCodecTag()
get_TargetAudioBitrate()
get_TargetAudioChannels()
get_TargetAudioCodec()
get_TargetVideoCodec()
get_TargetSize()
get_TargetVideoBitrate()
get_TargetTimestamp()
get_TargetTotalBitrate()
get_IsTargetAnamorphic()
get_IsTargetInterlaced()
get_IsTargetAVC()
get_TargetWidth()
get_TargetHeight()
get_TargetVideoStreamCount()
get_TargetAudioStreamCount()
SetOption(System.String,System.String,System.String)
SetOption(System.String,System.String)
GetOption(System.String,System.String)
GetOption(System.String)
ToUrl(System.String,System.String,System.String)
GetSubtitleProfiles(MediaBrowser.Model.Dlna.ITranscoderSupport,System.Boolean,System.String,System.String)
GetSubtitleProfiles(MediaBrowser.Model.Dlna.ITranscoderSupport,System.Boolean,System.Boolean,System.String,System.String)
AddSubtitleProfiles(System.Collections.Generic.List`1<MediaBrowser.Model.Dlna.SubtitleStreamInfo>,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Dlna.ITranscoderSupport,System.Boolean,System.String,System.String,System.Int64)
GetSubtitleStreamInfo(MediaBrowser.Model.Entities.MediaStream,System.String,System.String,System.Int64,MediaBrowser.Model.Dlna.SubtitleProfile[],MediaBrowser.Model.Dlna.ITranscoderSupport)
GetTargetVideoBitDepth(System.String)
GetTargetAudioBitDepth(System.String)
GetTargetVideoLevel(System.String)
GetTargetRefFrames(System.String)
GetTargetAudioChannels(System.String)
GetMediaStreamCount(MediaBrowser.Model.Entities.MediaStreamType,System.Int32)