public async Task <IDictionary <long, Program> > LoadAsync(CancellationToken cancellationToken)
{
ICollection <Uri> playlists = this.Playlists;
IDictionary <long, Program> dictionary;
foreach (Uri uri in (IEnumerable <Uri>)playlists)
{
try
{
M3U8Parser parser = new M3U8Parser();
if (null != this._playlistWebReader)
{
this._playlistWebReader.Dispose();
}
this._playlistWebReader = this._webReaderManager.CreateReader(uri, ContentKind.Playlist, (IWebReader)null, (ContentType)null);
Uri actualPlaylist = await M3U8ParserExtensions.ParseAsync(parser, this._playlistWebReader, this._retryManager, uri, cancellationToken).ConfigureAwait(false);
dictionary = await this.LoadAsync(this._playlistWebReader, parser, cancellationToken);
goto label_14;
}
catch (WebException ex)
{
Debug.WriteLine("HlsProgramManager.LoadAsync: " + ex.Message);
}
}
dictionary = HlsProgramManager.NoPrograms;
label_14:
return(dictionary);
}
private async Task UpdateAsync(M3U8Parser parser, CancellationToken cancellationToken)
{
_segments = await _segmentsFactory.CreateSegmentsAsync(parser, _subPlaylistCache.WebReader, cancellationToken).ConfigureAwait(false);
_isDynamicPlaylist = HlsPlaylistSettings.Parameters.IsDynamicPlaylist(parser);
_actualUrl = parser.BaseUrl;
}
public async Task RefreshPlaylistAsync(CancellationToken cancellationToken)
{
if (this._isDynamicPlaylist || this._segments == null || this._segments.Count <= 0)
{
M3U8Parser parser = await this.FetchPlaylistAsync(cancellationToken).ConfigureAwait(false);
await this.UpdateAsync(parser, cancellationToken).ConfigureAwait(false);
}
}
public void CheckCameraDownload()
{
var mainNode = GetMainNode();
var m3U8 = mainNode["live"]["amba.m3u8"];
var webResponse = m3U8.DownloadContent();
var parser = new M3U8Parser(webResponse.GetResponseStream());
webResponse.Dispose();
Assert.AreEqual("3", parser.Version);
}
public static bool IsDynamicPlayist(M3U8Parser parser)
{
if (null != M3U8TagInstanceExtensions.Tag(parser.GlobalTags, M3U8Tags.ExtXEndList))
{
return(false);
}
return(Enumerable.All <M3U8Parser.M3U8Uri>(parser.Playlist, (Func <M3U8Parser.M3U8Uri, bool>)(p =>
{
ExtinfTagInstance extinfTagInstance = M3U8Tags.ExtXInf.Find((IEnumerable <M3U8TagInstance>)p.Tags);
return extinfTagInstance != null && extinfTagInstance.Duration >= new Decimal(0);
})));
}
public static bool IsDynamicPlayist(M3U8Parser parser)
{
if (null != M3U8TagInstanceExtensions.Tag(parser.GlobalTags, M3U8Tags.ExtXEndList))
{
return(false);
}
return(parser.Playlist.All(p =>
{
var extinfTagInstance = M3U8Tags.ExtXInf.Find(p.Tags);
return extinfTagInstance != null && extinfTagInstance.Duration >= new decimal(0);
}));
}
private async Task <M3U8Parser> FetchPlaylistAsync(CancellationToken cancellationToken)
{
var urls = Urls;
if (urls == null || urls.Count < 1)
{
return(null);
}
foreach (Uri playlist in urls)
{
UpdateSubPlaylistCache(playlist);
cancellationToken.ThrowIfCancellationRequested();
WebResponse webResponse = null;
if (null == StreamMetadata)
{
webResponse = new WebResponse();
}
var parsedPlaylist = await _subPlaylistCache.ReadAsync((actualUri, bytes) =>
{
cancellationToken.ThrowIfCancellationRequested();
if (bytes.Length < 1)
{
return(null);
}
var parser = new M3U8Parser();
using (var memoryStream = new MemoryStream(bytes))
{
parser.Parse(actualUri, memoryStream);
}
return(parser);
}, cancellationToken, webResponse).ConfigureAwait(false);
if (null != parsedPlaylist)
{
if (null != webResponse)
{
StreamMetadata = _webMetadataFactory.CreateStreamMetadata(webResponse);
}
return(parsedPlaylist);
}
}
return(null);
}
private async Task <M3U8Parser> FetchPlaylistAsync(CancellationToken cancellationToken)
{
ICollection <Uri> urls = this.Urls;
M3U8Parser m3U8Parser;
if (urls == null || urls.Count < 1)
{
m3U8Parser = (M3U8Parser)null;
}
else
{
foreach (Uri playlist in (IEnumerable <Uri>)urls)
{
this.UpdateSubPlaylistCache(playlist);
cancellationToken.ThrowIfCancellationRequested();
WebResponse webResponse = (WebResponse)null;
if (null == this.StreamMetadata)
{
webResponse = new WebResponse();
}
M3U8Parser parsedPlaylist = await this._subPlaylistCache.ReadAsync <M3U8Parser>((Func <Uri, byte[], M3U8Parser>)((actualUri, bytes) =>
{
cancellationToken.ThrowIfCancellationRequested();
if (bytes.Length < 1)
{
return((M3U8Parser)null);
}
M3U8Parser parser = new M3U8Parser();
using (MemoryStream memoryStream = new MemoryStream(bytes))
M3U8ParserExtensions.Parse(parser, actualUri, (Stream)memoryStream, (Encoding)null);
return(parser);
}), cancellationToken, webResponse).ConfigureAwait(false);
if (null != parsedPlaylist)
{
if (null != webResponse)
{
this.StreamMetadata = this._webMetadataFactory.CreateStreamMetadata(webResponse, (ContentType)null);
}
m3U8Parser = parsedPlaylist;
goto label_16;
}
}
m3U8Parser = (M3U8Parser)null;
}
label_16:
return(m3U8Parser);
}
public HlsStreamSegments(M3U8Parser parser, IWebReader webReader, IRetryManager retryManager, IPlatformServices platformServices)
{
if (null == parser)
{
throw new ArgumentNullException("parser");
}
if (null == webReader)
{
throw new ArgumentNullException("webReader");
}
if (null == retryManager)
{
throw new ArgumentNullException("retryManager");
}
if (null == platformServices)
{
throw new ArgumentNullException("platformServices");
}
this._parser = parser;
this._webReader = webReader;
this._retryManager = retryManager;
this._platformServices = platformServices;
this._mediaSequence = M3U8Tags.ExtXMediaSequence.GetValue <long>(parser.GlobalTags);
}
public async Task <IDictionary <long, Program.Program> > LoadAsync(CancellationToken cancellationToken)
{
var playlists = Playlists;
foreach (var uri in playlists)
{
try
{
var parser = new M3U8Parser();
_playlistWebReader?.Dispose();
_playlistWebReader = _webReaderManager.CreateReader(uri, ContentKind.Playlist);
var actualPlaylist = await parser.ParseAsync(_playlistWebReader, _retryManager, uri, cancellationToken).ConfigureAwait(false);
var dictionary = await LoadAsync(_playlistWebReader, parser, cancellationToken);
return(dictionary);
}
catch (WebException ex)
{
Debug.WriteLine("HlsProgramManager.LoadAsync: " + ex.Message);
}
}
return(_noPrograms);
}
public Task SetParserAsync(M3U8Parser parser, CancellationToken cancellationToken)
{
UpdateSubPlaylistCache(parser.BaseUrl);
return(UpdateAsync(parser, cancellationToken));
}
public IHlsStreamSegments Create(M3U8Parser parser, IWebReader webReader)
{
return((IHlsStreamSegments) new HlsStreamSegments(parser, webReader, this._retryManager, this._platformServices));
}
public void CheckCameraDownload()
{
var mainNode = GetMainNode();
var m3U8 = mainNode["live"]["amba.m3u8"];
var webResponse=m3U8.DownloadContent();
var parser = new M3U8Parser(webResponse.GetResponseStream());
webResponse.Dispose();
Assert.AreEqual("3",parser.Version);
}
public Task <ICollection <ISegment> > CreateSegmentsAsync(M3U8Parser parser, IWebReader webReader, CancellationToken cancellationToken)
{
return(_streamSegmentsFactory.Create(parser, webReader).CreateSegmentsAsync(cancellationToken));
}
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);
}
private async Task <IDictionary <long, Program> > LoadAsync(IWebReader webReader, M3U8Parser parser, CancellationToken cancellationToken)
{
Dictionary <string, HlsProgramManager.MediaGroup> audioStreams = new Dictionary <string, HlsProgramManager.MediaGroup>();
foreach (M3U8TagInstance m3U8TagInstance in parser.GlobalTags)
{
if (M3U8Tags.ExtXMedia == m3U8TagInstance.Tag)
{
try
{
if (null != M3U8TagInstanceExtensions.Attribute <string>(m3U8TagInstance, ExtMediaSupport.AttrType, "AUDIO"))
{
HlsProgramManager.AddMedia(parser.BaseUrl, m3U8TagInstance, audioStreams);
}
}
catch (NullReferenceException ex)
{
}
}
}
Dictionary <long, Program> programs = new Dictionary <long, Program>();
bool hasSegments = false;
foreach (M3U8Parser.M3U8Uri m3U8Uri in parser.Playlist)
{
if (m3U8Uri.Tags == null || m3U8Uri.Tags.Length < 1)
{
hasSegments = true;
}
else
{
ExtStreamInfTagInstance streamInfTagInstance = M3U8Tags.ExtXStreamInf.Find((IEnumerable <M3U8TagInstance>)m3U8Uri.Tags);
long programId = long.MinValue;
HlsProgramManager.MediaGroup mediaGroup = (HlsProgramManager.MediaGroup)null;
if (null != streamInfTagInstance)
{
M3U8AttributeValueInstance <long> attributeValueInstance1 = M3U8TagInstanceExtensions.Attribute <long>((M3U8TagInstance)streamInfTagInstance, ExtStreamInfSupport.AttrProgramId);
if (null != attributeValueInstance1)
{
programId = attributeValueInstance1.Value;
}
string key = M3U8TagInstanceExtensions.AttributeObject <string>((M3U8TagInstance)streamInfTagInstance, ExtStreamInfSupport.AttrAudio);
if (null != key)
{
audioStreams.TryGetValue(key, out mediaGroup);
}
Uri uri = M3U8ParserExtensions.ResolveUrl(parser, m3U8Uri.Uri);
M3U8AttributeValueInstance <long> attributeValueInstance2 = M3U8TagInstanceExtensions.Attribute <long>((M3U8TagInstance)streamInfTagInstance, ExtStreamInfSupport.AttrBandwidth);
ResolutionAttributeInstance attributeInstance = M3U8TagInstanceExtensions.AttributeInstance <ResolutionAttributeInstance>((M3U8TagInstance)streamInfTagInstance, ExtStreamInfSupport.AttrResolution);
Uri baseUrl = parser.BaseUrl;
Program program = HlsProgramManager.GetProgram((IDictionary <long, Program>)programs, programId, baseUrl);
IHlsProgramStream hlsProgramStream = this._programStreamFactory.Create((ICollection <Uri>) new Uri[1]
{
uri
}, webReader);
PlaylistSubProgram playlistSubProgram1 = new PlaylistSubProgram((IProgram)program, (IProgramStream)hlsProgramStream);
playlistSubProgram1.Bandwidth = attributeValueInstance2 == null ? 0L : attributeValueInstance2.Value;
playlistSubProgram1.Playlist = uri;
playlistSubProgram1.AudioGroup = mediaGroup;
PlaylistSubProgram playlistSubProgram2 = playlistSubProgram1;
if (null != attributeInstance)
{
playlistSubProgram2.Width = new int?(attributeInstance.X);
playlistSubProgram2.Height = new int?(attributeInstance.Y);
}
program.SubPrograms.Add((ISubProgram)playlistSubProgram2);
}
else
{
hasSegments = true;
}
}
}
if (hasSegments)
{
Program program = HlsProgramManager.GetProgram((IDictionary <long, Program>)programs, long.MinValue, parser.BaseUrl);
IHlsProgramStream hlsProgramStream = this._programStreamFactory.Create((ICollection <Uri>) new Uri[1]
{
webReader.RequestUri
}, webReader);
await hlsProgramStream.SetParserAsync(parser, cancellationToken).ConfigureAwait(false);
PlaylistSubProgram subProgram = new PlaylistSubProgram((IProgram)program, (IProgramStream)hlsProgramStream);
program.SubPrograms.Add((ISubProgram)subProgram);
}
return((IDictionary <long, Program>)programs);
}
