/// <summary>
/// Returns true if Conversation instances are equal
/// </summary>
/// <param name="other">Instance of Conversation to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(Conversation other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
ConversationId == other.ConversationId ||
ConversationId != null &&
ConversationId.Equals(other.ConversationId)
) &&
(
Token == other.Token ||
Token != null &&
Token.Equals(other.Token)
) &&
(
ExpiresIn == other.ExpiresIn ||
ExpiresIn != null &&
ExpiresIn.Equals(other.ExpiresIn)
) &&
(
StreamUrl == other.StreamUrl ||
StreamUrl != null &&
StreamUrl.Equals(other.StreamUrl)
) &&
(
ReferenceGrammarId == other.ReferenceGrammarId ||
ReferenceGrammarId != null &&
ReferenceGrammarId.Equals(other.ReferenceGrammarId)
) &&
(
ETag == other.ETag ||
ETag != null &&
ETag.Equals(other.ETag)
));
}
/// <summary>
/// ノードリストを解析する
/// </summary>
/// <param name="segmentDuration"></param>
/// <param name="playListNodes"></param>
/// <returns></returns>
private IStreamInfo Parse(uint segmentDuration, List <IPlaylistNode> playListNodes, string baseUrl)
{
var stream = new StreamInfo(segmentDuration);
IResolution?resolution = default;
long bandWidth = 0;
int streamIndex = 0;
foreach (int i in Enumerable.Range(0, playListNodes.Count))
{
IPlaylistNode node = playListNodes[i];
switch (node.NodeType)
{
case PlayListNodeType.Uri:
IStreamUrl sUrl = new StreamUrl(node.Content, baseUrl, streamIndex);
stream.StreamUrls.Add(sUrl);
streamIndex++;
break;
case PlayListNodeType.PlaylistUri:
if (resolution is null || bandWidth == 0)
{
throw new Exception($"ストリームの解像度・帯域が不明です。({i + 1}行目)");
}
IPlaylistUrl pUrl = new PlaylistUrl(node.Content, baseUrl, resolution, bandWidth);
stream.PlaylistUrls.Add(pUrl);
resolution = default;
bandWidth = 0;
break;
case PlayListNodeType.StreamInfo:
resolution = node.PlaylistResolution;
bandWidth = node.PlaylistBandWidth;
break;
}
}
return(stream);
}
// number - artist - title(version)(Explicit).flac
public static string GetTrackPath2(Settings settings, Track track, StreamUrl stream, Album album, Playlist playlist = null)
{
//hyphen
string hyphen = " ";
if (settings.AddHyphen)
{
hyphen = " - ";
}
//get number
string number = "";
if (settings.UseTrackNumber)
{
number = track.TrackNumber.ToString().PadLeft(2, '0') + hyphen;
if (playlist != null)
{
number = (playlist.Tracks.IndexOf(track) + 1).ToString().PadLeft(2, '0') + hyphen;
}
}
//get artist
string artist = "";
if (settings.ArtistBeforeTitle)
{
artist = FormatPath(track.Artists[0].Name, settings, false) + hyphen;
}
//get explicit
string sexplicit = "";
if (settings.AddExplicitTag && track.Explicit)
{
sexplicit = "(Explicit)";
}
//get version
string version = "";
if (track.Version.IsNotBlank())
{
version = "(" + track.Version + ")";
}
//get title
string title = FormatPath(track.Title, settings, false);
//get extension
string extension = getExtension(stream.Url);
//base path
string basepath = null;
if (playlist == null)
{
basepath = GetAlbumPath(album, settings);
if (album.NumberOfVolumes > 1)
{
basepath += $"CD{track.VolumeNumber}/";
}
}
else
{
basepath = GetPlaylistPath(playlist, settings);
}
string path = $"{basepath}{number}{artist}{title}{version}{sexplicit}{extension}";
return(path);
}
// "{TrackNumber} - {ArtistName} - {TrackTitle}{ExplicitFlag}";
public static string GetTrackPath(Settings settings, Track track, StreamUrl stream, Album album, Playlist playlist = null)
{
string number = track.TrackNumber.ToString().PadLeft(2, '0');
if (playlist != null)
{
number = (playlist.Tracks.IndexOf(track) + 1).ToString().PadLeft(2, '0');
}
string artist = FormatPath(track.Artists[0].Name, settings, false);
//get explicit
string sexplicit = "";
if (settings.AddExplicitTag && track.Explicit)
{
sexplicit = "(Explicit)";
}
//get version
string version = "";
if (track.Version.IsNotBlank())
{
version = "(" + track.Version + ")";
}
//get title
string title = FormatPath(track.Title + version, settings, false);
//get extension
string extension = getExtension(stream.Url);
//base path
string basepath = null;
if (playlist == null)
{
basepath = GetAlbumPath(album, settings);
if (album.NumberOfVolumes > 1)
{
basepath += $"CD{track.VolumeNumber}/";
}
}
else
{
basepath = GetPlaylistPath(playlist, settings);
}
string name = settings.TrackFileFormat;
if (name.IsBlank())
{
name = "{TrackNumber} - {ArtistName} - {TrackTitle}{ExplicitFlag}";
}
name = name.Replace("{TrackNumber}", number);
name = name.Replace("{ArtistName}", artist);
name = name.Replace("{TrackTitle}", title);
name = name.Replace("{ExplicitFlag}", sexplicit);
return($"{basepath}{name}{extension}");
}
public byte[] GetStreamAudio(StreamUrl url)
{
byte[] audio = { };
try
{
using (WebClient client = new WebClient())
{
client.Proxy = Proxy;
client.Headers.Add("user-agent", _useragent);
audio = client.DownloadData(url.url);
}
}
catch (WebException error)
{
ThrowError("Retrieving audio stream failed!", error);
audio = new byte[] { };
}
return audio;
}
public void DownloadTrack()
{
string Errlabel = "";
//GetStream
Progress.StatusMsg = "GetStream...";
StreamUrl TidalStream = TidalTool.getStreamUrl(TidalTrack.ID.ToString(), Quality, out Errlabel);
if (Errlabel.IsNotBlank())
{
goto ERR_RETURN;
}
//Get path
FilePath = TidalTool.getTrackPath(OutputDir, TidalAlbum, TidalTrack, TidalStream.Url, AddHyphen, TidalPlaylist, artistBeforeTitle: ArtistBeforeTitle);
//Check if song is downloaded already
string CheckName = OnlyM4a ? FilePath.Replace(".mp4", ".m4a") : FilePath;
if (CheckExist && System.IO.File.Exists(CheckName))
{
Progress.Update(100, 100);
Progress.SetStatus(ProgressHelper.STATUS.COMPLETE);
return;
}
//Get contributors
ObservableCollection <Contributor> pContributors = TidalTool.getTrackContributors(TidalTrack.ID.ToString(), out Errlabel);
//To chinese
if (ToChinese)
{
CloudMusicAlbum cloalbum = Chinese.matchAlbum(TidalAlbum.Title, TidalAlbum.Artist.Name);
string chnname = Chinese.convertSongTitle(TidalTrack.Title, cloalbum);
if (chnname != TidalTrack.Title)
{
FilePath = TidalTool.getTrackPath(OutputDir, TidalPlaylist != null ? null : TidalAlbum, TidalTrack, TidalStream.Url, AddHyphen, TidalPlaylist, chnname, artistBeforeTitle: ArtistBeforeTitle);
TidalTrack.Title = chnname;
}
}
//Download
Progress.StatusMsg = "Start...";
for (int i = 0; i < 100 && Progress.GetStatus() != ProgressHelper.STATUS.CANCLE; i++)
{
if ((bool)DownloadFileHepler.Start(TidalStream.Url, FilePath, Timeout: 5 * 1000, UpdateFunc: UpdateDownloadNotify, ErrFunc: ErrDownloadNotify, Proxy:TidalTool.PROXY))
{
//Decrypt
if (!TidalTool.DecryptTrackFile(TidalStream, FilePath))
{
Errlabel = "Decrypt failed!";
goto ERR_RETURN;
}
if (OnlyM4a)
{
string sNewName;
if (!TidalTool.ConvertMp4ToM4a(FilePath, out sNewName))
{
Errlabel = "Convert mp4 to m4a failed!";
goto ERR_RETURN;
}
else
{
FilePath = sNewName;
}
}
//SetMetaData
if (TidalAlbum == null && TidalTrack.Album != null)
{
string sErrcode = null;
TidalAlbum = TidalTool.getAlbum(TidalTrack.Album.ID.ToString(), out sErrcode);
}
string sLabel = TidalTool.SetMetaData(FilePath, TidalAlbum, TidalTrack, TidalTool.getAlbumCoverPath(OutputDir, TidalAlbum), pContributors);
if (sLabel.IsNotBlank())
{
Errlabel = "Set metadata failed!";
goto ERR_RETURN;
}
Progress.SetStatus(ProgressHelper.STATUS.COMPLETE);
return;
}
}
Errlabel = "Download failed!";
ERR_RETURN:
if (Progress.GetStatus() == ProgressHelper.STATUS.CANCLE)
{
return;
}
ErrlabelHeight = 15;
Progress.SetStatus(ProgressHelper.STATUS.ERROR);
Progress.Errmsg = Errlabel;
}
public void DownloadTrack()
{
//GetStream
Progress.StatusMsg = "GetStream...";
string Errlabel = "";
StreamUrl TidalStream = TidalTool.getStreamUrl(TidalTrack.ID.ToString(), Quality, out Errlabel);
if (Errlabel.IsNotBlank())
{
goto ERR_RETURN;
}
FilePath = TidalTool.getAlbumTrackPath(OutputDir, TidalAlbum, TidalTrack, TidalStream.Url);
//Download
Progress.StatusMsg = "Start...";
for (int i = 0; i < 100 && Progress.GetStatus() != ProgressHelper.STATUS.CANCLE; i++)
{
if ((bool)DownloadFileHepler.Start(TidalStream.Url, FilePath, Timeout: 5 * 1000, UpdateFunc: UpdateDownloadNotify, ErrFunc: ErrDownloadNotify))
{
//Decrypt
if (!TidalTool.DecryptTrackFile(TidalStream, FilePath))
{
Errlabel = "Decrypt failed!";
goto ERR_RETURN;
}
if (OnlyM4a)
{
string sNewName;
if (!TidalTool.ConvertMp4ToM4a(FilePath, out sNewName))
{
Errlabel = "Convert mp4 to m4a failed!";
ErrlabelHeight = 15;
}
else
{
FilePath = sNewName;
}
}
//SetMetaData
string sLabel = TidalTool.SetMetaData(FilePath, TidalAlbum, TidalTrack, TidalTool.getAlbumCoverPath(OutputDir, TidalAlbum));
if (sLabel.IsNotBlank())
{
Errlabel = "Set metadata failed!";
goto ERR_RETURN;
}
Progress.SetStatus(ProgressHelper.STATUS.COMPLETE);
return;
}
}
Errlabel = "Download failed!";
ERR_RETURN:
if (Progress.GetStatus() == ProgressHelper.STATUS.CANCLE)
{
return;
}
ErrlabelHeight = 15;
Progress.SetStatus(ProgressHelper.STATUS.ERROR);
Progress.Errmsg = Errlabel;
}
public void DownloadTrack()
{
string Errlabel = "";
//GetStream
Progress.StatusMsg = "GetStream...";
StreamUrl TidalStream = TidalTool.getStreamUrl(TidalTrack.ID.ToString(), Quality, out Errlabel);
if (Errlabel.IsNotBlank())
{
goto ERR_RETURN;
}
//Get path
FilePath = TidalTool.getTrackPath(OutputDir, TidalAlbum, TidalTrack, TidalStream.Url, AddHyphen, TidalPlaylist);
//Get contributors
ObservableCollection <Contributor> pContributors = TidalTool.getTrackContributors(TidalTrack.ID.ToString(), out Errlabel);
//Download
Progress.StatusMsg = "Start...";
for (int i = 0; i < 100 && Progress.GetStatus() != ProgressHelper.STATUS.CANCLE; i++)
{
if ((bool)DownloadFileHepler.Start(TidalStream.Url, FilePath, Timeout: 5 * 1000, UpdateFunc: UpdateDownloadNotify, ErrFunc: ErrDownloadNotify, Proxy:TidalTool.PROXY))
{
//Decrypt
if (!TidalTool.DecryptTrackFile(TidalStream, FilePath))
{
Errlabel = "Decrypt failed!";
goto ERR_RETURN;
}
if (OnlyM4a)
{
string sNewName;
if (!TidalTool.ConvertMp4ToM4a(FilePath, out sNewName))
{
Errlabel = "Convert mp4 to m4a failed!";
ErrlabelHeight = 15;
}
else
{
FilePath = sNewName;
}
}
//SetMetaData
if (TidalAlbum == null && TidalTrack.Album != null)
{
string sErrcode = null;
TidalAlbum = TidalTool.getAlbum(TidalTrack.Album.ID.ToString(), out sErrcode);
}
string sLabel = TidalTool.SetMetaData(FilePath, TidalAlbum, TidalTrack, TidalTool.getAlbumCoverPath(OutputDir, TidalAlbum), pContributors);
if (sLabel.IsNotBlank())
{
Errlabel = "Set metadata failed!";
goto ERR_RETURN;
}
Progress.SetStatus(ProgressHelper.STATUS.COMPLETE);
return;
}
}
Errlabel = "Download failed!";
ERR_RETURN:
if (Progress.GetStatus() == ProgressHelper.STATUS.CANCLE)
{
return;
}
ErrlabelHeight = 15;
Progress.SetStatus(ProgressHelper.STATUS.ERROR);
Progress.Errmsg = Errlabel;
}
public void Download()
{
string Errlabel = "";
//GetStream
Progress.StatusMsg = "GetStream...";
StreamUrl TidalStream = TidalTool.getStreamUrl(TidalTrack.ID.ToString(), Quality, out Errlabel);
if (Errlabel.IsNotBlank() || TidalStream == null)
{
goto ERR_RETURN;
}
if (TidalStream.Codec != "ac4" && TidalStream.Codec != "mha1")
{
if (Quality >= eSoundQuality.LOSSLESS)
{
if (TidalStream.Url.Contains(".m4a") || TidalStream.Url.Contains(".mp4"))
{
StreamUrl TidalStream2 = TidalTool.getStreamUrl2(TidalTrack.ID.ToString(), Quality, out Errlabel);
if (Errlabel.IsBlank() && TidalStream2 != null)
{
TidalStream = TidalStream2;
}
Errlabel = "";
}
}
}
Codec = TidalStream.Codec;
Progress.StatusMsg = "GetStream success...";
//Get path
FilePath = TidalTool.getTrackPath(OutputDir, TidalAlbum, TidalTrack, TidalStream.Url,
AddHyphen, TidalPlaylist, artistBeforeTitle: ArtistBeforeTitle, addexplicit: AddExplict,
addYear: AddYear, useTrackNumber: UseTrackNumber);
//Check if song is downloaded already
string CheckName = OnlyM4a ? FilePath.Replace(".mp4", ".m4a") : FilePath;
if (CheckExist && System.IO.File.Exists(CheckName))
{
Progress.UpdateInt(100, 100);
Progress.SetStatus(ProgressHelper.STATUS.COMPLETE);
goto CALL_RETURN;
}
//Get contributors
Progress.StatusMsg = "GetContributors...";
ObservableCollection <Contributor> pContributors = TidalTool.getTrackContributors(TidalTrack.ID.ToString(), out Errlabel);
//Download
Progress.StatusMsg = "Start...";
for (int i = 0; i < 100 && Progress.GetStatus() != ProgressHelper.STATUS.CANCLE; i++)
{
if ((bool)DownloadFileHepler.Start(TidalStream.Url, FilePath, Timeout: 5 * 1000, UpdateFunc: UpdateDownloadNotify, ErrFunc: ErrDownloadNotify, Proxy: TidalTool.PROXY))
{
//Decrypt
if (!TidalTool.DecryptTrackFile(TidalStream, FilePath))
{
Errlabel = "Decrypt failed!";
goto ERR_RETURN;
}
if (OnlyM4a && Path.GetExtension(FilePath).ToLower().IndexOf("mp4") >= 0)
{
if (TidalStream.Codec != "ac4" && TidalStream.Codec != "mha1")
{
string sNewName;
if (!Config.IsFFmpegExist())
{
Errlabel = "Convert mp4 to m4a failed!(FFmpeg is not exist!)";
goto ERR_RETURN;
}
if (!TidalTool.ConvertMp4ToM4a(FilePath, out sNewName))
{
Errlabel = "Convert mp4 to m4a failed!(No reason, Please feedback!)";
goto ERR_RETURN;
}
else
{
FilePath = sNewName;
}
}
}
//SetMetaData
if (TidalAlbum == null && TidalTrack.Album != null)
{
string sErrcode = null;
TidalAlbum = TidalTool.getAlbum(TidalTrack.Album.ID.ToString(), out sErrcode);
}
string sLabel = TidalTool.SetMetaData(FilePath, TidalAlbum, TidalTrack, TidalTool.getAlbumCoverPath(OutputDir, TidalAlbum, AddYear), pContributors);
if (sLabel.IsNotBlank())
{
Errlabel = "Set metadata failed!" + sLabel;
goto ERR_RETURN;
}
Progress.SetStatus(ProgressHelper.STATUS.COMPLETE);
goto CALL_RETURN;
}
}
Errlabel = "Download failed!";
ERR_RETURN:
if (Progress.GetStatus() == ProgressHelper.STATUS.CANCLE)
{
goto CALL_RETURN;
}
Progress.SetStatus(ProgressHelper.STATUS.ERROR);
Progress.Errmsg = Errlabel;
CALL_RETURN:
TellParentOver();
}
