private ISegment CreateStreamSegment(M3U8Parser.M3U8Uri uri, CancellationToken cancellationToken)
        {
            SubStreamSegment segment = new SubStreamSegment(_parser.ResolveUrl(uri.Uri), _parser.BaseUrl);

            if (_mediaSequence.HasValue)
            {
                SubStreamSegment subStreamSegment = segment;
                long?            nullable1        = _mediaSequence;
                long             num       = _segmentIndex;
                long?            nullable2 = nullable1.GetValueOrDefault() + num;
                subStreamSegment.MediaSequence = nullable2;
            }
            ++_segmentIndex;
            M3U8TagInstance[] m3U8TagInstanceArray = uri.Tags;
            if (m3U8TagInstanceArray == null || 0 == m3U8TagInstanceArray.Length)
            {
                return(segment);
            }
            ExtinfTagInstance extinfTagInstance = M3U8Tags.ExtXInf.Find(m3U8TagInstanceArray);

            if (null != extinfTagInstance)
            {
                segment.Duration = TimeSpan.FromSeconds((double)extinfTagInstance.Duration);
            }
            ByterangeTagInstance byteRange = M3U8Tags.ExtXByteRange.Find(m3U8TagInstanceArray);

            if (null != byteRange)
            {
                HandleByteRange(segment, byteRange);
            }
            IEnumerable <ExtKeyTagInstance> all = M3U8Tags.ExtXKey.FindAll(m3U8TagInstanceArray);

            if (null != all)
            {
                HandleKey(segment, all, cancellationToken);
            }
            return(segment);
        }
        private async Task <IDictionary <long, Program.Program> > LoadAsync(IWebReader webReader, M3U8Parser parser, CancellationToken cancellationToken)
        {
            var audioStreams = new Dictionary <string, MediaGroup>();

            foreach (var m3U8TagInstance in parser.GlobalTags)
            {
                if (M3U8Tags.ExtXMedia != m3U8TagInstance.Tag)
                {
                    continue;
                }

                try
                {
                    if (null != m3U8TagInstance.Attribute(ExtMediaSupport.AttrType, "AUDIO"))
                    {
                        AddMedia(parser.BaseUrl, m3U8TagInstance, audioStreams);
                    }
                }
                catch (NullReferenceException)
                {
                    ;
                }
            }

            var programs    = new Dictionary <long, Program.Program>();
            var hasSegments = false;

            foreach (var m3U8Uri in parser.Playlist)
            {
                if (m3U8Uri.Tags == null || m3U8Uri.Tags.Length < 1)
                {
                    hasSegments = true;
                }
                else
                {
                    var        streamInfTagInstance = M3U8Tags.ExtXStreamInf.Find(m3U8Uri.Tags);
                    var        programId            = long.MinValue;
                    MediaGroup mediaGroup           = null;
                    if (null != streamInfTagInstance)
                    {
                        var attributeValueInstance1 = streamInfTagInstance.Attribute(ExtStreamInfSupport.AttrProgramId);
                        if (null != attributeValueInstance1)
                        {
                            programId = attributeValueInstance1.Value;
                        }

                        var key = streamInfTagInstance.AttributeObject(ExtStreamInfSupport.AttrAudio);
                        if (null != key)
                        {
                            audioStreams.TryGetValue(key, out mediaGroup);
                        }

                        var uri = parser.ResolveUrl(m3U8Uri.Uri);
                        var attributeValueInstance2 = streamInfTagInstance.Attribute(ExtStreamInfSupport.AttrBandwidth);
                        var attributeInstance       = streamInfTagInstance.AttributeInstance <ResolutionAttributeInstance>(ExtStreamInfSupport.AttrResolution);
                        var baseUrl             = parser.BaseUrl;
                        var program             = GetProgram(programs, programId, baseUrl);
                        var hlsProgramStream    = _programStreamFactory.Create(new [] { uri }, webReader);
                        var playlistSubProgram1 = new PlaylistSubProgram(program, hlsProgramStream);
                        playlistSubProgram1.Bandwidth  = attributeValueInstance2?.Value ?? 0L;
                        playlistSubProgram1.Playlist   = uri;
                        playlistSubProgram1.AudioGroup = mediaGroup;
                        var playlistSubProgram2 = playlistSubProgram1;
                        if (null != attributeInstance)
                        {
                            playlistSubProgram2.Width  = attributeInstance.X;
                            playlistSubProgram2.Height = attributeInstance.Y;
                        }
                        program.SubPrograms.Add(playlistSubProgram2);
                    }
                    else
                    {
                        hasSegments = true;
                    }
                }
            }
            if (hasSegments)
            {
                var program          = GetProgram(programs, long.MinValue, parser.BaseUrl);
                var hlsProgramStream = _programStreamFactory.Create(new [] { webReader.RequestUri }, webReader);
                await hlsProgramStream.SetParserAsync(parser, cancellationToken).ConfigureAwait(false);

                var subProgram = new PlaylistSubProgram(program, hlsProgramStream);
                program.SubPrograms.Add(subProgram);
            }
            return(programs);
        }