|
public static Create ( IFileAbstraction abstraction ) : |
||
| abstraction | IFileAbstraction |
/// A |
| return | ||
internal Result <List <MusicFileTag> > LoadMusicFilesFromRoot(string root)
{
var musicFileTags = new List <MusicFileTag>();
var foldersList = new List <string>();
foldersList.Add(root);
// add subfolders
foldersList.AddRange(this.GetSubfolders(root));
Regex reg = new Regex(@"^((?!\._).)*$");
foreach (var folder in foldersList)
{
var folderContent = Directory.GetFiles(folder, "*.mp3")
.Where(path => reg.IsMatch(path))
.ToList();
foreach (var file in folderContent)
{
try
{
var tagInfo = File.Create(file);
musicFileTags.Add(MusicFileTag.ConvertTagToMusicFileTag(tagInfo.Tag, tagInfo.Name));
}
catch (CorruptFileException e)
{
return(HandleError(file, e));
}
}
}
return(new Result <List <MusicFileTag> >(musicFileTags, Status.Success));
}
private async Task TagAudioFile(Video video, string filePath, CancellationToken cancellationToken)
{
// Try to extract artist/title from video title
if (!TryExtractArtistAndTitle(video.Title, out var artist, out var title))
{
return;
}
// Try to get tags
var tagsJson = await TryGetTagsJsonAsync(artist !, title !, cancellationToken);
// Try to get picture
var picture = await TryGetPictureAsync(video, cancellationToken);
// Extract information
var resolvedArtist = tagsJson?["artist-credit"]?.FirstOrDefault()?["name"]?.Value <string>();
var resolvedTitle = tagsJson?["title"]?.Value <string>();
var resolvedAlbumName = tagsJson?["releases"]?.FirstOrDefault()?["title"]?.Value <string>();
// Inject tags
var taggedFile = File.Create(filePath);
taggedFile.Tag.Performers = new[] { resolvedArtist ?? artist ?? "" };
taggedFile.Tag.Title = resolvedTitle ?? title ?? "";
taggedFile.Tag.Album = resolvedAlbumName ?? "";
taggedFile.Tag.Pictures = picture != null ? new[] { picture } : Array.Empty <IPicture>();
taggedFile.Save();
}
public static void Write(string path, Track track)
{
using (var file = File.Create(path))
{
file.Tag.Title = track.Title;
file.Tag.Performers = new[] { track.Artist.Name };
if (track.Album.Artist != null)
{
file.Tag.AlbumArtists = new[] { track.Album.Artist.Name };
}
file.Tag.Genres = new[] { track.Genre };
file.Tag.Album = track.Album.Title;
file.Tag.Track = (uint)track.TrackNumber;
file.Tag.TrackCount = (uint)(track.Album.GetNumberOfTracksOnDisc(track.DiscNumber) ?? 0);
file.Tag.Disc = (uint)track.DiscNumber;
file.Tag.DiscCount = (uint)(track.Album.GetTotalDiscs() ?? 0);
file.Tag.Year = (uint)track.Year;
file.Tag.Copyright = CopyrightText;
file.Tag.Comment = CopyrightText;
file.Save();
}
string fileName = null;
}
public static void Write(FileType fileType, string path, Track track)
{
ImageFile artworkFile = null;
var url = track.Album.CoverUri.ToString();
if (ImageCache.Instance.HasItem(url) && ImageCache.Instance.Get(url) != null)
{
artworkFile = ImageCache.Instance.Get(track.Album.CoverUri.ToString());
}
using (var file = File.Create(new File.LocalFileAbstraction(path), fileType.MimeType, ReadStyle.Average))
{
file.Tag.Title = track.Title;
file.Tag.Performers = new[] { track.Artist.Name };
if (track.Album.Artist != null)
{
file.Tag.AlbumArtists = new[] { track.Album.Artist.Name };
}
file.Tag.Genres = new[] { track.Genre };
file.Tag.Album = track.Album.Title;
file.Tag.Track = (uint)track.TrackNumber;
file.Tag.TrackCount = (uint)(track.Album.GetNumberOfTracksOnDisc(track.DiscNumber) ?? 0);
file.Tag.Disc = (uint)track.DiscNumber;
file.Tag.DiscCount = (uint)(track.Album.GetTotalDiscs() ?? 0);
file.Tag.Year = (uint)track.Year;
file.Tag.Copyright = CopyrightText;
file.Tag.Comment = CopyrightText;
if (artworkFile != null)
{
file.Tag.Pictures = new IPicture[] { new Picture(new ByteVector(artworkFile.Data)) };
}
file.Save();
}
string fileName = null;
switch (Program.DefaultSettings.Settings.AlbumArtworkSaveFormat)
{
case AlbumArtworkSaveFormat.DontSave:
break;
case AlbumArtworkSaveFormat.AsCover:
fileName = artworkFile?.FileType.Append("cover");
break;
case AlbumArtworkSaveFormat.AsArtistAlbum:
fileName = artworkFile?.FileType.Append($"{track.Artist} - {track.Album.Title}");
break;
default:
throw new ArgumentOutOfRangeException();
}
if (fileName != null && artworkFile != null)
{
var parentDir = Path.GetDirectoryName(path);
SysFile.WriteAllBytes(Path.Combine(parentDir, fileName), artworkFile.Data);
}
}
internal Result <List <MusicFileTag> > LoadMusicFilesFromList(List <string> folderContent)
{
var musicFileTags = new List <MusicFileTag>();
foreach (var file in folderContent)
{
try
{
// make sure only *.mp3 files are processed
FileInfo info = new FileInfo(file);
if (info.Extension != ".mp3")
{
continue;
}
var tagInfo = File.Create(file);
musicFileTags.Add(MusicFileTag.ConvertTagToMusicFileTag(tagInfo.Tag, tagInfo.Name));
}
catch (CorruptFileException e)
{
return(HandleError(file, e));
}
}
return(new Result <List <MusicFileTag> >(musicFileTags, Status.Success));
}
public static bool SaveTrack(TrackViewModel tv)
{
try
{
using (File f = File.Create(tv.Path))
{
f.Tag.Title = tv.Title;
f.Tag.Album = tv.Album;
f.Tag.Performers = new[] { tv.Artist };
f.Tag.Genres = new[] { tv.Genre };
f.Tag.Year = tv.Year;
f.Tag.Composers = new[] { tv.Composer };
f.Save();
}
}
catch (Exception e)
{
if (!pendingTagWrites.ContainsKey(tv.Path))
{
pendingTagWrites.Add(tv.Path, tv);
}
else
{ //remove previous one, and add the latest one
pendingTagWrites.Remove(tv.Path);
pendingTagWrites.Add(tv.Path, tv);
}
return(false);
}
return(true);
}
public void WriteTag()
{
File file = File.Create(OriginalPath);
if (file == null)
{
return;
}
// artist Song editor
file.Tag.Performers = new[] { Artist };
// album Song editor
file.Tag.Album = Album;
file.Tag.Genres = new[] { Genre };
file.Tag.Composers = Composers;
// song
file.Tag.Title = Title;
file.Tag.Track = Convert.ToUInt32(TrackNumber);
uint year = 0;
if (UInt32.TryParse(Year, out year))
{
file.Tag.Year = year;
}
// save
file.Save();
}
public override void LoadCover()
{
using (var tl = File.Create(new TagLibFileAbstraction(Item)))
{
InitCover(tl.Tag);
}
}
public void TestPrivateFrame()
{
MockFileSystem fileSystem = new MockFileSystem();
fileSystem.AddFile(@"C:\test.mp3", new MockFileData(System.IO.File.ReadAllBytes(@"TestData\test.mp3")));
File.IFileAbstraction mp3File = fileSystem.File.CreateFileAbstraction(@"C:\test.mp3");
File file = File.Create(mp3File);
Tag id3V2Tag = (Tag)file.GetTag(TagTypes.Id3v2, true);
// Get the private frame, create if necessary.
PrivateFrame frame = PrivateFrame.Get(id3V2Tag, "SW/Uid", true);
string uid = Guid.NewGuid().ToString("N");
frame.PrivateData = Encoding.Unicode.GetBytes(uid);
file.Save();
File actualFile = File.Create(mp3File);
id3V2Tag = (Tag)actualFile.GetTag(TagTypes.Id3v2, true);
// Get the private frame, create if necessary.
PrivateFrame actualFrame = PrivateFrame.Get(id3V2Tag, "SW/Uid", true);
// Set the frame data to your value. I am 90% sure that these are encoded with UTF-16.
string actualUid = Encoding.Unicode.GetString(actualFrame.PrivateData.Data);
actualUid.Should().Be(uid);
}
private File SaveToFile(string filePath, byte stars, List <Performer> performers, string album, uint trackNo, uint year,
string comment, string[] genres)
{
var file = File.Create(filePath);
var tag = file.TagTypes != TagTypes.Id3v2 ? file.Tag : file.GetTag(TagTypes.Id3v2);
var rating = tag.GetPopularimeterFrame();
if (rating != null)
{
rating.Rating = stars;
}
if (performers != null)
{
tag.Performers =
performers.Select(performer => performer.ToString()).Where(p => p != null).ToArray();
}
tag.Album = album;
if (trackNo != 0)
{
tag.Track = trackNo;
}
if (year != 0)
{
tag.Year = year;
}
tag.Comment = comment;
tag.Genres = genres;
return(SaveToFile(file, tag));
}
private async Task InjectAudioTagsAsync(
Video video,
string filePath,
CancellationToken cancellationToken = default)
{
if (!TryExtractArtistAndTitle(video.Title, out var artist, out var title))
{
return;
}
var tagsJson = await TryGetMusicBrainzTagsJsonAsync(artist !, title !, cancellationToken);
var picture = await TryGetPictureAsync(video, cancellationToken);
var resolvedArtist = tagsJson?["artist-credit"]?.FirstOrDefault()?["name"]?.Value <string>();
var resolvedTitle = tagsJson?["title"]?.Value <string>();
var resolvedAlbumName = tagsJson?["releases"]?.FirstOrDefault()?["title"]?.Value <string>();
var file = File.Create(filePath);
file.Tag.Performers = new[] { resolvedArtist ?? artist ?? "" };
file.Tag.Title = resolvedTitle ?? title ?? "";
file.Tag.Album = resolvedAlbumName ?? "";
file.Tag.Pictures = picture != null
? new[] { picture }
: Array.Empty <IPicture>();
file.Save();
}
public void TestWriteFlacUid()
{
var flacFile = string.Format("{0}\\{1:N}.flac", Path.GetTempPath(), Guid.NewGuid());
System.IO.File.Copy(@"TestData\hei.flac", flacFile, true);
var file = File.Create(flacFile);
Metadata metadata = (Metadata)file.GetTag(TagTypes.FlacMetadata, true);
XiphComment xiphComment = (XiphComment)metadata.Tags.First();
xiphComment.SetField("SW-AlbumUid", Guid.NewGuid().ToString("N"));
file.Save();
//metadata.SetTextFrame((ReadOnlyByteVector) "UFID", "http://www.id3.org/dummy/ufid.html", Guid.NewGuid().ToString("N"));
//file.Save();
//File actualFile = File.Create(mp3File);
//metadata = (Tag)actualFile.GetTag(TagTypes.Id3v2, true);
//// Get the private frame, create if necessary.
//var frame = metadata.GetFrames().FirstOrDefault(f => f.FrameId == "UFID");
//frame.Should().NotBeNull();
System.IO.File.Delete(flacFile);
}
public void Rewrite()
{
for (int i = 0; i < count; i++)
{
var tmp = Utils.CreateTmpFile(GetSampleFilename(i), GetTmpFilename(i));
tmp.Save();
tmp = File.Create(GetTmpFilename(i));
if ((TagTypes.TiffIFD & contained_types[i]) != 0)
{
CheckExif(tmp, i);
}
if ((TagTypes.XMP & contained_types[i]) != 0)
{
CheckXmp(tmp, i);
}
if ((TagTypes.JpegComment & contained_types[i]) != 0)
{
CheckJpegComment(tmp, i);
}
}
}
public TrackFull ReadTrack(int id, string path)
{
using (File file = File.Create(new File.LocalFileAbstraction(path))) {
MediaFormat mf = IdentifyFormat(file);
if (mf == MediaFormat.Unknown)
{
return(null);
}
Tag tag = file.Tag;
return(new TrackFull {
Id = id,
TrackNumber = tag.Track,
FileName = Path.GetFileName(path),
Title = tag.Title,
Artist = tag.FirstPerformer,
Year = tag.Year,
Album = tag.Album,
AlbumArtist = tag.FirstAlbumArtist,
Genre = tag.FirstGenre,
Length = (long)Math.Round(file.Properties.Duration.TotalSeconds),
MediaFormat = mf,
Bitrate = file.Properties.AudioBitrate
});
}
}
private void MaybeInit()
{
if (initialized)
{
return;
}
try
{
using (var tl = File.Create(new TagLibFileAbstraction(Item)))
{
try
{
duration = tl.Properties.Duration;
if (duration.Value.TotalSeconds < 0.1)
{
duration = null;
}
}
catch (Exception ex)
{
Debug("Failed to transpose Properties props", ex);
}
try
{
var t = tl.Tag;
SetProperties(t);
//InitCover(t);
}
catch (Exception ex)
{
Debug("Failed to transpose Tag props", ex);
}
}
initialized = true;
Server.UpdateFileCache(this);
}
catch (CorruptFileException ex)
{
Debug(
"Failed to read meta data via taglib for file " + Item.FullName, ex);
initialized = true;
}
catch (UnsupportedFormatException ex)
{
Debug(
"Failed to read meta data via taglib for file " + Item.FullName, ex);
initialized = true;
}
catch (Exception ex)
{
Warn(
"Unhandled exception reading meta data for file " + Item.FullName,
ex);
}
}
public void RemoveTags()
{
using (var mp3File = File.Create(filePath))
{
mp3File.RemoveTags(TagTypes.AllTags);
mp3File.Save();
}
}
private void RemoveAllTags(string path)
{
using (var tagLibFile = TagLibFile.Create(path))
{
tagLibFile.RemoveTags(TagTypes.AllTags);
tagLibFile.Save();
}
}
private void TrySetId3Tag()
{
using (var mp3File = File.Create(filePath))
{
SetTags(mp3File);
mp3File.Save();
}
}
private IEnumerable <RebuildWalkResult> ScanFiles()
{
return(_dirWalker.Walk(_sourceDir, fp =>
{
if (fp.IsMediaFile())
{
TagLibFile tLFile;
try
{
tLFile = TagLibFile.Create(fp);
}
catch (Exception e)
{
Console.WriteLine($"{e.GetType()}: {e.Message}");
return new RebuildWalkResult
{
IsValidToMove = false,
IsMediaFile = true,
OldPath = fp,
};
}
var filename = Path.GetFileName(fp);
var album = _fileSystemHelpers.MakeStringPathSafe(tLFile.Tag.Album ?? "");
var artistTag = string.Join(", ", tLFile.Tag.AlbumArtists).Trim();
if (string.IsNullOrWhiteSpace(artistTag))
{
artistTag = string.Join(", ", tLFile.Tag.Artists).Trim();
}
if (string.IsNullOrWhiteSpace(artistTag))
{
artistTag = string.Join(", ", tLFile.Tag.Performers).Trim();
}
var artist = _fileSystemHelpers.MakeStringPathSafe(artistTag);
var newPath = "";
var isValid = !string.IsNullOrWhiteSpace(album) && !string.IsNullOrWhiteSpace(artist);
if (isValid)
{
newPath = Path.Combine(_outDir, artist, album, filename);
}
return new RebuildWalkResult
{
Album = album,
Artist = artist,
IsValidToMove = isValid,
OldPath = fp,
NewPath = newPath,
IsMediaFile = true,
RequiresMove = fp != newPath
};
}
return new RebuildWalkResult
{
IsValidToMove = false,
IsMediaFile = false,
OldPath = fp,
};
}));
}
public static void Write(string serviceName, Track completedTrack, TrackFile trackFile, AlbumArtworkSaveFormat saveFormat, string path, bool writeWatermarkTags)
{
// Get album artwork from cache
ImageCacheEntry albumArtwork = null;
var smid = completedTrack.Album.GetSmid(serviceName).ToString();
if (ImageCache.Instance.HasItem(smid))
{
albumArtwork = ImageCache.Instance.Get(smid);
}
// Write track tags
var track = completedTrack;
using (var file = File.Create(new File.LocalFileAbstraction(path),
trackFile.FileType.MimeType, ReadStyle.Average))
{
file.Tag.Title = track.Title;
file.Tag.Performers = new[] { track.Artist.Name };
if (track.Album.Artist != null)
{
file.Tag.AlbumArtists = new[] { track.Album.Artist.Name };
}
if (track.Genre != null)
{
file.Tag.Genres = new[] { track.Genre };
}
file.Tag.Album = track.Album.Title;
file.Tag.Track = (uint)track.TrackNumber;
file.Tag.TrackCount = (uint)(track.Album.GetNumberOfTracksOnDisc(track.DiscNumber) ?? 0);
file.Tag.Disc = (uint)track.DiscNumber;
file.Tag.DiscCount = (uint)(track.Album.GetTotalDiscs() ?? 0);
file.Tag.Year = (uint)track.Year;
if (writeWatermarkTags)
{
file.Tag.Comment = WatermarkText;
}
if (albumArtwork != null)
{
file.Tag.Pictures = new IPicture[] { new TagLib.Picture(new ByteVector(albumArtwork.Data)) };
}
file.Save();
}
// Write album artwork to file if requested
if (albumArtwork == null)
{
return;
}
string parentDirectory;
if (saveFormat != AlbumArtworkSaveFormat.DontSave &&
(parentDirectory = Path.GetDirectoryName(path)) != null)
{
WriteArtworkFile(parentDirectory, saveFormat, track, albumArtwork);
}
}
public void SetValues(string fileInfo)
{
if (System.IO.File.Exists(fileInfo))
{
_isMulti = false;
_file = File.Create(fileInfo);
SetValues();
}
}
public void Init()
{
files = new File[count];
for (int i = 0; i < count; i++)
{
files[i] = File.Create(GetSampleFilename(i));
}
}
public void Iim_Keywords()
{
var file = File.Create(TestPath.Samples + "sample_iptc1.jpg");
var tag = file.GetTag(TagTypes.XMP) as XmpTag;
Assert.IsNotNull(tag, "tag");
CollectionAssert.AreEqual(new[] { "kw1", "kw2", "kw3 " }, tag.Keywords);
}
private void UpdateDBThread()
{
log.Debug("Database Update: Starting Database update thread");
_processCount = 0;
_audioFiles = 0;
OpenConnection();
while ((fileThread.ThreadState == ThreadState.Running || _processCount < files.Count) && !_abortScan)
{
if (_processCount == files.Count || files.Count == 0)
{
continue;
}
string fileName = files[_processCount].FullName;
if (Util.IsAudio(fileName))
{
_audioFiles++;
try
{
ByteVector.UseBrokenLatin1Behavior = true;
File file = File.Create(fileName);
AddSong(file);
}
catch (CorruptFileException)
{
log.Warn("FolderScan: Ignoring track {0} - Corrupt File!", fileName);
}
catch (UnsupportedFormatException)
{
log.Warn("FolderScan: Ignoring track {0} - Unsupported format!", fileName);
}
}
_processCount++;
}
CloseConnection();
_scanHasRun = true;
DateTime stopTime = DateTime.Now;
_ts = stopTime - _startTime;
float fSecsPerTrack = ((float)_ts.TotalSeconds / files.Count);
_trackPerSecSummary = "";
if (files.Count > 0)
{
_trackPerSecSummary = string.Format(localisation.ToString("Settings", "DBScanTrackSummary"), fSecsPerTrack);
}
log.Info(
"Database Update: Music database update done. Processed {0} tracks in: {1:d2}:{2:d2}:{3:d2}{4}",
_audioFiles, _ts.Hours, _ts.Minutes, _ts.Seconds, _trackPerSecSummary);
log.Debug("Database Update: Ending Database Update thread");
}
public static void DumpTrackMetadata(IO.FileStream file, string mimetype)
{
// Load up the file using TagLib
File tagFile;
try
{
tagFile = File.Create(new StreamFileAbstraction(file.Name, file, null), mimetype, ReadStyle.Average);
}
catch (UnsupportedFormatException)
{
Console.Error.WriteLine("*** The file format is not supported.");
return;
}
if (tagFile.PossiblyCorrupt)
{
Console.Error.WriteLine("*** The file is possibly corrupt. Reasons:");
Console.Error.WriteLine(" {0}", String.Join(",", tagFile.CorruptionReasons));
}
// Fetch the metadata from the file
if (tagFile.TagTypesOnDisk.HasFlag(TagTypes.Xiph))
{
Console.WriteLine("-----------------");
Console.WriteLine("Found XIPH Tags");
DumpXiphMetadata(tagFile);
}
if (tagFile.TagTypesOnDisk.HasFlag(TagTypes.Id3v2))
{
Console.WriteLine("-----------------");
Console.WriteLine("Found ID3v2");
DumpId3V2Metadata(tagFile);
}
if (tagFile.TagTypesOnDisk.HasFlag(TagTypes.Id3v1))
{
Console.WriteLine("-----------------");
Console.WriteLine("Found ID3v1 Tags");
//ReadId3V1Metadata(result, tagFile);
}
else if (tagFile.TagTypes.HasFlag(TagTypes.Asf))
{
//ReadAsfMetadata(result, tagFile);
}
else
{
//throw new DolomiteInternalException(null, "The file format is not supported.",
// String.Format("Mimetype {0} was read correctly, no supported TagTypesOnDisk are available. TagTypes: {1}",
// mimetype, tagFile.TagTypesOnDisk));
}
// Read the codec details and, optionally, the album art
//DumpCodecDetails(tagFile);
//ReadPictureDetails(result, tagFile);
}
/// <exception cref="FileException">Throws when mp3 file could not be loaded.</exception>
public void Reload()
{
try
{
this.mp3File = File.Create(this.WishedFilePath);
}
catch (UnsupportedFormatException)
{
throw new FileException(string.Format(Resources.TagLibMp3File_Exception_InvalidFilePath, this.WishedFilePath));
}
}
/// <exception cref="FileException">Throws when mp3 file could not be loaded.</exception>
public TagLibMp3File(string paramFilePath)
{
try
{
this.mp3File = File.Create(paramFilePath);
}
catch (UnsupportedFormatException)
{
throw new FileException(Resources.TagLibMp3File_Exception_InvalidFilePath, string.Format(Resources.TagLibMp3File_Inner_Exception_InvalidFilePath, paramFilePath));
}
}
public void ParseXmp()
{
var file = File.Create(sample_file, "taglib/jpeg", ReadStyle.Average) as TagLib.Image.File;
Assert.IsNotNull(file, "file");
var tag = file.ImageTag;
Assert.IsNotNull(tag, "ImageTag");
Assert.AreEqual("SONY ", tag.Make);
Assert.AreEqual("DSLR-A330", tag.Model);
}
/// <summary>
/// Confirms the file tags can actually be read, proving the file is valid.
/// TODO: Possibly find a better way to validate more file types quicker
/// TODO: perhaps by reading the resolved url ending rather than assuming mp3 immediately
/// </summary>
/// <returns>True if the file was downloaded correctly and can be modified</returns>
public override async Task <bool> Validate()
{
var valid = false;
var retry = false;
SFile file = null;
try
{
// Test if the file is a valid mp3
file = SFile.Create(MainResource.AbsolutePath);
}
catch (CorruptFileException) // File isn't mp3
{
try
{
// Check if the file is wma
var old = MainResource.AbsolutePath;
MainResource.AbsolutePath = MainResource.AbsolutePath.Substring(0,
MainResource.AbsolutePath.Length - 3) + "wma";
File.Move(old, MainResource.AbsolutePath);
file = SFile.Create(MainResource.AbsolutePath);
}
catch (CorruptFileException e) // File isn't any supported type
{
File.Delete(MainResource.AbsolutePath);
// If manual has already been attempted, this isn't possible
retry = !_forceManual;
if (!retry)
{
View.Report("Error!", true);
CrashHandler.Throw("Unable to download a valid song format for editing!", e);
}
}
}
finally
{
if (file != null)
{
valid = true;
file.Dispose();
}
}
// Retry the download if necessary
if (retry)
{
valid = await RetryDownload();
}
return(valid);
}
public void SetAudioFileAndTag(Stream stream, string fileName)
{
//Create a simple file and simple file abstraction
var simpleFile = new SimpleFile(fileName, stream);
var simpleFileAbstraction = new SimpleFileAbstraction(simpleFile);
/////////////////////
//Create a taglib file from the simple file abstraction
_songFile = File.Create(simpleFileAbstraction);
_tag = _songFile.Tag;
}