public void ShouldCreateStream()
{
var playlist = new M3uPlaylist
{
PlaylistEntries = new List <M3uPlaylistEntry>
{
new M3uPlaylistEntry
{
Title = "TVOne",
Uri = "http://local",
Name = "TvOne",
Logo = "http://logo",
SmallLogo = "http://local-small-logo",
Code = "123",
Group = "local",
Id = "12"
},
new M3uPlaylistEntry
{
Title = "TVTwo",
Logo = "http://logo2",
Uri = "http://local2"
}
}
};
var stream = M3UParser.M3uParser.CreateStream(playlist);
var content = M3UParser.M3uParser.GetFromStream(stream);
Assert.Equal(2, content.PlaylistEntries.Count);
Assert.Equal(playlist.PlaylistEntries[0].Title, content.PlaylistEntries[0].Title);
Assert.Equal(playlist.PlaylistEntries[1].Title, content.PlaylistEntries[1].Title);
}
public void Create_CreatePlaylistAndCompareWithFile_Equal()
{
M3uContent content = new M3uContent();
M3uPlaylist playlist = new M3uPlaylist();
playlist.IsExtended = false;
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "",
AlbumArtist = "",
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\04 Chiara.mp3",
Title = "",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\01 Con Te Partiro.mp3",
Title = null,
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "Unknown",
AlbumArtist = "Andrea Bocelli",
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\04 E Chiove.mp3",
Title = "E Chiove",
});
string created = content.ToText(playlist);
string fromFile = Helpers.Read("PlaylistNotExt.m3u");
Assert.AreEqual(created, fromFile);
}
public void Create_CreatePlaylistExtentedAndCompareWithFile_Equal()
{
M3uContent content = new M3uContent();
M3uPlaylist playlist = new M3uPlaylist();
playlist.IsExtended = true;
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "",
AlbumArtist = "",
Duration = TimeSpan.FromSeconds(254),
Path = @"D:\Muzyka\Andrea Bocelli\04 Chiara.mp3",
Title = "Andrea Bocelli - Chiara",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\01 Con Te Partiro.mp3",
Title = "Andrea Bocelli - Con Te Partiro",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "AndreaBocelli",
AlbumArtist = "Andrea Bocelli",
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\04 E Chiove.mp3",
Title = "Andrea Bocelli - E Chiove",
});
string created = content.Create(playlist);
string fromFile = Helpers.Read("PlaylistExt.m3u");
Assert.AreEqual(created, fromFile);
}
private M3uPlaylist MapToEntity(IPlaylist playlist)
{
M3uPlaylist m3UPlaylist = new M3uPlaylist();
m3UPlaylist.IsExtended = true;
m3UPlaylist.Comments.Add($"PLAYLIST-Author:{playlist.Author}");
m3UPlaylist.Comments.Add($"PLAYLIST-Title:{playlist.Name}");
m3UPlaylist.Comments.Add($"PLAYLIST-CreatedAt:{playlist.CreatedAt}");
foreach (var item in playlist.Items)
{
var entry = new M3uPlaylistEntry()
{
Duration = item.Duration,
Path = item.Path,
Title = item.Title,
Comments = new List <string>()
};
m3UPlaylist.PlaylistEntries.Add(entry);
}
return(m3UPlaylist);
}
public static Stream CreateStream(M3uPlaylist playlistData)
{
using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream))
{
streamWriter.WriteLine(Directives.EXTM3U);
foreach (var entry in playlistData.PlaylistEntries)
{
if (string.IsNullOrWhiteSpace(entry.Title))
{
throw new ArgumentNullException(entry.Title);
}
if (string.IsNullOrWhiteSpace(entry.Uri))
{
throw new ArgumentNullException(entry.Uri);
}
var chainAttributes = Helpers.ChainAttributes(entry);
streamWriter.WriteLine(chainAttributes);
streamWriter.WriteLine(entry.Uri);
}
streamWriter.Flush();
memoryStream.Position = 0;
return(new MemoryStream(memoryStream.ToArray(), false));
}
}
private static string SerializePlaylist(IPlaylist playlist, Format fileFormat)
{
switch (fileFormat)
{
case Format.XSPF:
var xspfSerializer = new XspfSerializer();
var xspfPl = new XspfPlaylist(playlist);
return(xspfSerializer.Serialize(xspfPl));
case Format.WPL:
var wplSerializer = new WplSerializer();
var wplPlaylist = new WplPlaylist(playlist);
return(wplSerializer.Serialize(wplPlaylist));
case Format.M3U:
var m3USerializer = new M3uSerializer();
var m3UPlaylist = new M3uPlaylist(playlist);
return(m3USerializer.Serialize(m3UPlaylist));
case Format.ASX:
var asxSerializer = new AsxSerializer();
var asxPlaylist = new AsxPlaylist(playlist);
return(asxSerializer.Serialize(asxPlaylist));
case Format.PLS:
var plsSerializer = new PlsSerializer();
var plsPlaylist = new PlsPlaylist(playlist);
return(plsSerializer.Serialize(plsPlaylist));
}
return(String.Empty);
}
public void CreatePlaylist(ObservableCollection <MusicFileTag> musicFileTags, string filePath)
{
foreach (var tag in musicFileTags)
{
SaveTagToFile(tag);
}
M3uPlaylist playlist = new M3uPlaylist
{
IsExtended = true
};
foreach (var tag in musicFileTags)
{
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Path = tag.FilePath,
});
}
// save playlist
M3uContent content = new M3uContent();
StreamWriter SW = new StreamWriter(filePath);
SW.WriteLine(content.ToText(playlist));
SW.Close();
}
private void CreatePlaylist()
{
string folder = textBoxFolder.Text;
string textPlaylist = string.Empty;
string playlistExtension = string.Empty;
switch (comboBoxPlaylist.SelectedItem)
{
case Constants.WinMediaPlayerPLS:
PlsPlaylist plsPlaylist = new PlsPlaylist();
playlistExtension = "pls";
foreach (var episode in listBoxEpisodes.Items)
{
plsPlaylist.PlaylistEntries.Add(new PlsPlaylistEntry()
{
Path = Path.Combine(folder, episode.ToString()),
Title = Path.GetFileNameWithoutExtension(episode.ToString())
});
}
PlsContent plsContent = new PlsContent();
textPlaylist = plsContent.ToText(plsPlaylist);
break;
case Constants.WinampM3U:
M3uPlaylist m3uPlaylist = new M3uPlaylist();
playlistExtension = "m3u";
foreach (var episode in listBoxEpisodes.Items)
{
m3uPlaylist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Path = Path.Combine(folder, episode.ToString()),
Title = Path.GetFileNameWithoutExtension(episode.ToString())
});
}
M3uContent m3uContent = new M3uContent();
textPlaylist = m3uContent.ToText(m3uPlaylist);
break;
default:
break;
}
string playlistName = $"Playlist - {Utils.GetTimestamp(DateTime.Now)}";
string playlistFullName = Path.Combine(folder, $"{playlistName}.{playlistExtension}");
using (FileStream fs = File.Create(playlistFullName))
{
byte[] info = new UTF8Encoding(true).GetBytes(textPlaylist);
fs.Write(info, 0, info.Length);
}
}
public static void PlayPlayList(List <MusicItem> m)
{
M3uContent content = new M3uContent();
M3uPlaylist lst = Generate(m);
string created = content.ToText(lst);
SaveToFile(created);
}
public void RefreshList(string _url)
{
if (!string.IsNullOrEmpty(_url))
{
url = _url;
}
string contents;
try
{
using (var wc = new WebClient())
{
contents = wc.DownloadString(url);
}
var parser = PlaylistParserFactory.GetPlaylistParser(".m3u");
IBasePlaylist playlist = parser.GetFromString(contents);
M3uPlaylist m3uList = (M3uPlaylist)playlist;
channelsInfo.Clear();
groupsInfo.Clear();
int channelNumber = 0;
SeenResumeChannels src = SeenResumeChannels.Get();
foreach (M3uPlaylistEntry entry in m3uList.PlaylistEntries)
{
if (entry.CustomProperties.Count > 0)
{
ChannelInfo channelInfo = new ChannelInfo(entry);
channelInfo.seen = src.IsSeen(channelInfo.Title);
channelInfo.currentPostion = src.GetCurrentPosition(channelInfo.Title);
channelsInfo.Add(channelNumber, channelInfo);
channelInfo.ChNumber = channelNumber;
GrpInfo groupInfo = new GrpInfo();
groupInfo.Title = channelInfo.TVGGroup;
groupInfo.Show = channelInfo.ChannelType == ChType.SHOW;
if (!groupsInfo.ContainsKey(groupInfo))
{
groupsInfo[groupInfo] = new List <ChannelInfo>();
}
groupsInfo[groupInfo].Add(channelInfo);
channelNumber++;
}
}
if (File.Exists(Utils.CONF_PATH + "channelCache.json"))
{
File.Delete(Utils.CONF_PATH + "channelCache.json");
}
using (StreamWriter file = File.CreateText(Utils.CONF_PATH + "channelCache.json"))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(file, channelsInfo.Values);
}
needRefresh = true;
Task <string> stats = Utils.GetAsync("http://amian.es:5085/stats?ctype=connected&app=net&chn=CONNECT");
} catch (Exception ex) {
Console.WriteLine("Some error occur");
needRefresh = false;
}
}
public override string ToString()
{
var playlist = new M3uPlaylist();
playlist.PlaylistEntries.AddRange(this.Select(entry => new M3uPlaylistEntry {
Path = entry
}));
return(new M3u8Content().Create(playlist));
}
public void Serialize_HasAMedia_MediaIsCorrectlyFormated()
{
var playlist = new M3uPlaylist();
playlist.Add(new M3uItem("foo", 42.42m));
var serializer = new M3uSerializer();
var output = serializer.Serialize(playlist);
output.Should().MatchRegex($"#EXTINF:42.42{newlinePattern}foo{newlinePattern}");
}
public void Save(string filePath, IPlaylist playlist)
{
M3uPlaylist m3uPlaylist = MapToEntity(playlist);
M3uContent content = new M3uContent();
string text = content.ToText(m3uPlaylist);
using (StreamWriter sw = new StreamWriter(filePath))
{
sw.Write(text);
}
}
static M3uPlaylist GetPlaylistFromFile(string path)
{
var playlist = new M3uPlaylist();
var content = new M3uContent();
using (MemoryStream ms = new MemoryStream())
using (FileStream stream = File.Open(path, FileMode.Open))
{
playlist = content.GetFromStream(stream);
}
return(playlist);
}
public void Serialize_HasAMedia_MediaIsCorrectlyFormated()
{
var playlist = new M3uPlaylist();
playlist.Add(new M3uItem("foo", 42.42m));
var output = serializer.Serialize(playlist);
var pattern =
@"#EXTINF:42.42" + newlinePattern
+ @"foo" + newlinePattern;
Assert.Matches(pattern, output);
}
public void Serialize_HasAMediaWithNormalTitle_TitleIsTrimmedAndAdded()
{
var playlist = new M3uPlaylist();
playlist.Add(new M3uItem("foo", 0)
{
Title = "\t Foo \t"
});
var serializer = new M3uSerializer();
var output = serializer.Serialize(playlist);
output.Should().MatchRegex($"#EXTINF:0, Foo{newlinePattern}");
}
public void GetFromStream_ReadPlaylistNotExtendedAndCompareWithObject_Equal()
{
M3uContent content = new M3uContent();
M3uPlaylist playlist = new M3uPlaylist();
playlist.IsExtended = false;
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "",
AlbumArtist = "",
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\04 Chiara.mp3",
Title = "",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\01 Con Te Partiro.mp3",
Title = null,
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "Unknown",
AlbumArtist = "Andrea Bocelli",
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\04 E Chiove.mp3",
Title = "E Chiove",
});
using (var stream = Helpers.ReadStream("PlaylistNotExt.m3u"))
{
var file = content.GetFromStream(stream);
Assert.AreEqual(playlist.IsExtended, file.IsExtended);
Assert.AreEqual(playlist.PlaylistEntries.Count, file.PlaylistEntries.Count);
Assert.AreEqual(playlist.PlaylistEntries[0].Path, file.PlaylistEntries[0].Path);
Assert.AreEqual(playlist.PlaylistEntries[0].Title, file.PlaylistEntries[0].Title);
Assert.AreEqual(playlist.PlaylistEntries[1].Path, file.PlaylistEntries[1].Path);
Assert.AreNotEqual(playlist.PlaylistEntries[1].Title, file.PlaylistEntries[1].Title);
Assert.IsNull(playlist.PlaylistEntries[1].Title);
Assert.AreEqual("", file.PlaylistEntries[1].Title);
Assert.AreEqual(playlist.PlaylistEntries[2].Path, file.PlaylistEntries[2].Path);
Assert.AreNotEqual(playlist.PlaylistEntries[2].Title, file.PlaylistEntries[2].Title);
}
}
public void Serialize_HasAMediaWithWhitespaceTitle_TitleIsIgnored()
{
var playlist = new M3uPlaylist();
playlist.Add(new M3uItem("foo", 0)
{
Title = " \t"
});
var serializer = new M3uSerializer();
var output = serializer.Serialize(playlist);
output.Should().MatchRegex($"#EXTINF:0{newlinePattern}");
}
public void GetFromStream_ReadPlaylistExtendedAndCompareWithObject_Equal()
{
M3uContent content = new M3uContent();
M3uPlaylist playlist = new M3uPlaylist();
playlist.IsExtended = true;
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "",
AlbumArtist = "",
Duration = TimeSpan.FromSeconds(254),
Path = @"D:\Muzyka\Andrea Bocelli\04 Chiara.mp3",
Title = "Andrea Bocelli - Chiara",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\01 Con Te Partiro.mp3",
Title = "Andrea Bocelli - Con Te Partiro",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "AndreaBocelli",
AlbumArtist = "Andrea Bocelli",
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\04 E Chiove.mp3",
Title = "Andrea Bocelli - E Chiove",
});
var stream = Helpers.ReadStream("PlaylistExt.m3u");
var file = content.GetFromStream(stream);
stream.Dispose();
Assert.AreEqual(playlist.IsExtended, file.IsExtended);
Assert.AreEqual(playlist.PlaylistEntries.Count, file.PlaylistEntries.Count);
Assert.AreEqual(playlist.PlaylistEntries[0].Path, file.PlaylistEntries[0].Path);
Assert.AreEqual(playlist.PlaylistEntries[0].Title, file.PlaylistEntries[0].Title);
Assert.AreEqual(playlist.PlaylistEntries[0].Album, file.PlaylistEntries[0].Album);
Assert.AreEqual(playlist.PlaylistEntries[0].AlbumArtist, file.PlaylistEntries[0].AlbumArtist);
Assert.AreEqual(playlist.PlaylistEntries[1].Path, file.PlaylistEntries[1].Path);
Assert.AreEqual(playlist.PlaylistEntries[1].Title, file.PlaylistEntries[1].Title);
Assert.AreNotEqual(playlist.PlaylistEntries[1].Album, file.PlaylistEntries[1].Album);
Assert.AreNotEqual(playlist.PlaylistEntries[1].AlbumArtist, file.PlaylistEntries[1].AlbumArtist);
Assert.AreEqual(playlist.PlaylistEntries[2].Path, file.PlaylistEntries[2].Path);
Assert.AreEqual(playlist.PlaylistEntries[2].Title, file.PlaylistEntries[2].Title);
Assert.AreEqual(playlist.PlaylistEntries[2].Album, file.PlaylistEntries[2].Album);
Assert.AreEqual(playlist.PlaylistEntries[2].AlbumArtist, file.PlaylistEntries[2].AlbumArtist);
}
public void Serialize_HasAMediaWithNormalTitle_TitleIsTrimmedAndAdded()
{
var playlist = new M3uPlaylist();
playlist.Add(new M3uItem("foo", 0)
{
Title = "\t Foo \t"
});
var output = serializer.Serialize(playlist);
var pattern = @"#EXTINF:0, Foo" + newlinePattern;
Assert.Matches(pattern, output);
}
public void Serialize_HasAMediaWithWhitespaceTitle_TitleIsIgnored()
{
var playlist = new M3uPlaylist();
playlist.Add(new M3uItem("foo", 0)
{
Title = " \t"
});
var output = serializer.Serialize(playlist);
var pattern = @"#EXTINF:0" + newlinePattern;
Assert.Matches(pattern, output);
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
M3uContent playlistContent = new M3uContent();
M3uPlaylist savePlaylist = new M3uPlaylist
{
IsExtended = false
};
foreach (Item item in Playlist)
{
savePlaylist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Path = item.FilePath
});
}
string textPlaylist = playlistContent.Create(savePlaylist);
var savePicker = new FileSavePicker
{
SuggestedStartLocation = PickerLocationId.DocumentsLibrary,
SuggestedFileName = "New Playlist"
};
savePicker.FileTypeChoices.Add("M3U Playlist", new List <string>()
{
".m3u"
});
StorageFile playlistFile = await savePicker.PickSaveFileAsync();
if (playlistFile != null)
{
CachedFileManager.DeferUpdates(playlistFile);
await FileIO.WriteTextAsync(playlistFile, textPlaylist);
FileUpdateStatus status = await CachedFileManager.CompleteUpdatesAsync(playlistFile);
if (status == FileUpdateStatus.Complete)
{
ToastNotificationManager.CreateToastNotifier().Show(new ToastNotificationBuilder().Build(
"vMix List Maker",
"Playlist " + playlistFile.Name + " saved successfully!"
));
}
}
}
static void Main(string[] args)
{
var iTunesXml = @"C:\Users\matth\Music\iTunes\iTunes Music Library.xml";
var library = new ITunesLibrary(iTunesXml);
var tracks = library.Tracks;
// returns all tracks in the iTunes Library
var albums = library.Albums;
// returns all albums in the iTunes Library
var playlists = library.Playlists;
foreach (var playlist in playlists.Where(p => p.Tracks != null && p.Tracks.Count() != 0))
{
Console.WriteLine(playlist.Name);
var serviceCollection = new ServiceCollection();
serviceCollection.AddLogging();
var playlistOutput = new M3uPlaylist
{
IsExtended = true
};
foreach (var track in playlist.Tracks)
{
if (track.Location != null)
{
playlistOutput.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = track.Album,
AlbumArtist = track.Artist,
Path = track.Location.Replace("file://localhost/D:/iTunesMedia/Music", "..").Replace("%20", " "),
Title = track.Name
});
}
}
var content = new M3uContent();
string text = content.ToText(playlistOutput);
File.WriteAllText(@"\\192.168.1.2\music\playlists\" + playlist.Name + ".m3u", text);
}
}
public static List <ChannelInfo> LoadChannellist()
{
string localFilePath = "ASTRA_19_2E.m3u";
if (!File.Exists(localFilePath))
{
new WebClient().DownloadFile(_m3uUrl, localFilePath);
}
M3uContent content = new M3uContent();
M3uPlaylist playlist = content.GetFromStream(File.OpenRead(localFilePath));
List <ChannelInfo> channelList = playlist.PlaylistEntries.Select(item => new ChannelInfo()
{
Name = item.Title, Url = item.Path
}).ToList();
return(channelList);
}
private static M3uPlaylist Generate(List <MusicItem> m)
{
var l = new M3uPlaylist();
l.IsExtended = false;
l.PlaylistEntries = new List <M3uPlaylistEntry>();
foreach (var mi in m)
{
l.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = string.Empty,
AlbumArtist = mi.Artist,
Duration = TimeSpan.Zero,
Path = mi.FullFileName,
Title = mi.Title,
});
}
return(l);
}
/// <summary>
/// Returns the playlist in m3u format.
/// </summary>
private string CreateM3uPlaylist()
{
var playlist = new M3uPlaylist()
{
IsExtended = App.UserSettings.M3uExtended,
};
foreach (Track track in _album.Tracks)
{
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = _album.Title,
AlbumArtist = _album.Artist,
Duration = TimeSpan.FromSeconds(track.Duration),
Path = Path.GetFileName(track.Path),
Title = track.Title,
});
}
return(new M3uContent().ToText(playlist));
}
private static void PrepareMail(DateTime now, List <string> result, M3uPlaylist playlist, out string mailBody, out string mailSubject)
{
var mailXml = new XmlDocument();
var langCode = configFile.AppSettings.Settings["MailLangCode"].Value;
mailXml.Load("MailTexts.xml");
var playlistEntries = playlist.PlaylistEntries;
var newResult = result.Select(p => p + Environment.NewLine + playlistEntries.First(x => x.Title == p).Path + Environment.NewLine).ToList();
mailBody = mailXml.SelectSingleNode($"/MailText/NewEntriesCaption[@lang-code='{langCode}']").InnerText + Environment.NewLine;
mailBody += Environment.NewLine;
mailBody += String.Join(Environment.NewLine, newResult);
mailBody += Environment.NewLine;
mailBody += Environment.NewLine;
mailBody += $"-- {mailXml.SelectSingleNode($"/MailText/MailSignature[@lang-code='{langCode}']").InnerText} :)";
mailBody += Environment.NewLine;
mailSubject = "Duyuru! IPTVNotifier - Yeni eklenen içerik - " + now.ToString("dd/MM/yyyy - HH:mm");
}
public M3uPlaylist ConvertFileListToM3UPlaylist()
{
M3uPlaylist PlaylistFile = new M3uPlaylist
{
IsExtended = true
};
foreach (PlaylistEntry file in Files)
{
PlaylistFile.PlaylistEntries.Add(new M3uPlaylistEntry
{
Duration = file.SongData.Length,
Title = file.SongData.Title,
Album = file.SongData.Album,
AlbumArtist = file.SongData.Artist,
Path = file.SongData.FileName
});
}
return(PlaylistFile);
}
public void ShouldCreateStreamThrowExceptionIfUriIsNotGiven()
{
var playlist = new M3uPlaylist
{
PlaylistEntries = new List <M3uPlaylistEntry>
{
new M3uPlaylistEntry
{
Title = "TVOne",
Name = "TvOne",
Logo = "http://logo",
SmallLogo = "http://local-small-logo",
Code = "123",
Group = "local",
Id = "12"
}
}
};
Assert.Throws <ArgumentNullException>(() => M3UParser.M3uParser.CreateStream(playlist));
}
public IPlaylist Load(string filePath)
{
IPlaylist playlist = null;
M3uPlaylist m3uPlaylistBase = null;
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
{
return(null);
}
using (StreamReader sr = new StreamReader(filePath))
{
M3uContent content = new M3uContent();
m3uPlaylistBase = content.GetFromStream(sr.BaseStream);
}
m3uPlaylistBase.Path = filePath;
playlist = MapToDomain(m3uPlaylistBase);
return(playlist);
}
