public ZuneMP3TagContainer(File file)
: base(file)
{
//if we can't find the id3v2 tag we will create it, this will handle cases
//where we load a tag with id3v1 only
_tag = (Tag) file.GetTag(TagTypes.Id3v2, true);
}
public utwor(String path)
{
//Console.WriteLine("sciezka = path;");
sciezka = path;
//Console.WriteLine("if (!System.IO.File.Exists(path))");
if (!System.IO.File.Exists(path))
{
nazwa = "Błąd: Plik nie istnieje.";
return;
}
//Console.WriteLine("rozszerzenie = System.IO.Path.GetExtension(path).Substring(1);");
rozszerzenie = System.IO.Path.GetExtension(path).Substring(1);
nazwa = System.IO.Path.GetFileNameWithoutExtension(path);
staraNazwa = System.IO.Path.GetFileNameWithoutExtension(path);
//Console.WriteLine("");
if (!wspierane_rozszerzenia.Contains(rozszerzenie))
{
//nazwa = "Błąd: Nie wspierane rozszerzenie: " + rozszerzenie;
throw new NotSupportedException("Błąd: Nie wspierane rozszerzenie: " + rozszerzenie);
}
else
{
//Console.WriteLine("tagi = TagLib.File.Create(path);");
tagi = TagLib.File.Create(path);
stareTagi = TagLib.File.Create(path);
przepisz_tagi();
}
}
public Composition(string path, PropertyChangedEventHandler PropertyChanged)
{
this.PropertyChanged += PropertyChanged;
FileInfo = TagLib.File.Create(path);
if (FileInfo.Tag.Artists.Length == 0)
Artists = "Unknown artist";
else
{
foreach (string str in FileInfo.Tag.Artists)
{
Artists += str;
Artists += "; ";
}
Artists = Artists.Substring(0, Artists.Length - 2);
}
if (FileInfo.Tag.Title == null)
Title = "Unknown title";
else
Title = FileInfo.Tag.Title;
if (FileInfo.Tag.Album == null)
Album = "Unknown album";
else
Album = FileInfo.Tag.Album;
Name = FileInfo.Name;
Image = new BitmapImage();
Image.BeginInit();
if (FileInfo.Tag.Pictures.Length != 0)
Image.StreamSource = new MemoryStream(FileInfo.Tag.Pictures[0].Data.Data);
else
Image.UriSource = new Uri("Content\\note-blue.png", UriKind.RelativeOrAbsolute);
Image.EndInit();
}
private static void renameToArtistTitle(FileInfo[] files)
{
foreach (FileInfo file in files)
{
string filePath = file.FullName;
TagLib.File musicFile = TagLib.File.Create(filePath);
string artist = String.Join("/", musicFile.Tag.Performers);
if (artist == null)
{
artist = "<unknown>";
}
artist = MakeValidFileName(artist);
string title = musicFile.Tag.Title;
musicFile.Dispose();
if (title != null)
{
title = MakeValidFileName(title);
try
{
System.IO.File.Move(filePath, "C:/Users/steng/Desktop/New folder/" + artist + "-" + title + ".mp3");
}
catch (IOException e)
{
if (e.Message == "Cannot create a file when that file already exists.\r\n")
{
System.IO.File.Move(filePath, "C:/Users/steng/Desktop/New folder/" + artist + "-" + title + "_.mp3");
}
}
}
}
}
public string Title(string sPath)
{
TagLib.File music = TagLib.File.Create(sPath);
String title = music.Tag.Title;
return(title);
}
private void SetNameFromMetaData(MetaData md)
{
bool title = !String.IsNullOrEmpty(md.Tag.Title);
bool artist = !String.IsNullOrEmpty(md.Tag.FirstPerformer);
if (title && artist)
{
Name = md.Tag.FirstPerformer + " - " + md.Tag.Title;
}
else if (!String.IsNullOrEmpty(md.Tag.FirstAlbumArtist) && title)
{
Name = md.Tag.FirstAlbumArtist + " - " + md.Tag.Title;
}
else if (!title && artist)
{
Name = md.Tag.FirstPerformer + " - " +
// ReSharper disable once AssignNullToNotNullAttribute
Regex.Replace(input: System.IO.Path.GetFileNameWithoutExtension(Path), pattern: @"[\d-]", replacement: "", options: RegexOptions.Multiline)
.TrimStart();
}
else
{
Name = "Unknown Artist - " +
// ReSharper disable once AssignNullToNotNullAttribute
Regex.Replace(input: System.IO.Path.GetFileNameWithoutExtension(Path), pattern: @"[\d-]", replacement: "", options: RegexOptions.Multiline)
.TrimStart();
}
//Flacs seem to stay for some reason, manually remove.
Name = Name.Replace(".flac", "");
//Remove the brackets left over on duplicate files in Windows.
Name = Name.Replace("()", "");
}
public async Task <ContentResult> Upload()
{
string url = "http://webapplication5020160822045658.azurewebsites.net/api/Account/upload3";
HttpClient client = new HttpClient();
string token = Request.Cookies["access_token"].Value;
client.DefaultRequestHeaders.Add("access_token", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjU4Zjg1ZjRjLTY4ZTAtNDQ2NC04ZjhlLWQyNTU5NTk0NDg0NyIsImVtYWlsIjoiZmpqIn0.5y4MRuONaoK1QsJ_BEzoiOG01bqKsW7__kaLs2_3cU4");
var file = Request.Files["file"];
var stream = file.InputStream;
HttpContent fileContent = new StreamContent(stream);
TagLib.File myFile = TagLib.File.Create(new HttpPostedFileAbstraction(file));
MultipartFormDataContent mulContent = new MultipartFormDataContent("----ferfefjeofjfjejf");
fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
mulContent.Add(fileContent, "file", file.FileName);
int duration = (myFile.Properties.Duration.Minutes * 60 + myFile.Properties.Duration.Minutes) * 1000;
duration += myFile.Properties.Duration.Milliseconds;
mulContent.Add(new StringContent(duration.ToString()), "song_duration");
mulContent.Add(new StringContent(myFile.Tag.Title), "song_name");
mulContent.Add(new StringContent(myFile.Tag.Performers.FirstOrDefault()), "author");
HttpResponseMessage response;
response = await client.PostAsync(new Uri(url), mulContent);
// response.EnsureSuccessStatusCode();
string result = await response.Content.ReadAsStringAsync();
return(Content(result));
}
// GET: Upload
public ActionResult Upload()
{
IndexViewModel invm = new IndexViewModel();
List <ivm> ivm = new List <ivm>();
DateTime from_date = DateTime.Now.AddDays(-1);
DateTime to_date = DateTime.Now;
List <String> todaysFiles = new List <String>();
foreach (String file in Directory.GetDirectories(@"\\51-DBA\radio\Music\", "*.*", SearchOption.AllDirectories))
{
DirectoryInfo di = new DirectoryInfo(file);
if (di.LastWriteTime >= from_date)
{
todaysFiles.Add(file);
}
}
foreach (var item in todaysFiles)
{
string[] files = Directory.GetFiles(@"\\" + item, "*.*", SearchOption.AllDirectories).ToArray();
foreach (var song in files)
{
TrackList index = new TrackList();
if (song.Contains(".mp3") || song.Contains(".flac") || song.Contains(".m4a") || song.Contains(".m4p") || song.Contains(".wma") || song.Contains(".aiff") || song.Contains(".wav") || song.Contains(".alac") ||
song.Contains(".ogg")) //|| item.Contains(".png") || item.Contains(".jpg"))
{
TagLib.File file = TagLib.File.Create(song);
index.Location = "/music/" + file.Name.Substring(23);
var checkentries = db.TrackLists.FirstOrDefault(x => x.Location == index.Location);
if (checkentries == null)
{
index.Title = file.Tag.Title;
index.Album = file.Tag.Album;
index.TrackNumber = checked ((int?)file.Tag.Track);
index.Artist = file.Tag.FirstPerformer;
index.Duration = file.Properties.Duration.ToString();
index.Genre = file.Tag.FirstGenre;
index.TimeAdded = DateTime.Now;
db.TrackLists.Add(index);
db.SaveChanges();
}
}
}
}
var sidebar = db.PlaylistNames.Select(x => x.PlaylistName1).Distinct().ToList();
foreach (var item in sidebar)
{
playlist pl = new playlist();
pl.Playlist = item;
invm.PlayList.Add(pl);
}
invm.PlayList = invm.PlayList.ToList();
invm.indexview = invm.indexview.ToList();
return(RedirectToAction("Index", "Home"));
}
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 static BitmapSource GetPicture(string path)
{
TL.File media = TL.File.Create(path);
BitmapSource bs = getPic(media.Tag);
media.Dispose();
return(bs);
}
static void LogWarnings(string filename, File file)
{
if (!file.PossiblyCorrupt)
return;
foreach (var reason in file.CorruptionReasons)
Log.WarnFormat("{0} is possibly corrupt: {1}", filename, reason);
}
// Constructor
public Metadata(string filename)
{
file = TagLib.File.Create(filename);
if (file == null || file.Tag == null || file.Properties.MediaTypes != TagLib.MediaTypes.Audio)
{
throw new System.Exception(System.String.Format(string_error_load, filename));
}
}
private void TrySetId3Tag()
{
using (var mp3File = File.Create(filePath))
{
SetTags(mp3File);
mp3File.Save();
}
}
public void CheckXmp(File file, int i)
{
var tag = file.GetTag(TagTypes.XMP) as XmpTag;
Assert.IsNotNull(tag, $"XMP Tag not contained: index {i}");
Assert.AreEqual("test description", tag.Comment);
}
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();
}
}
public static void SetInterpret(this TagLib.File item, string newInterpret)
{
if (newInterpret != null)
{
item.Tag.Performers = new string[] { newInterpret }
}
;
}
public static void SetGenre(this TagLib.File item, string newGenre)
{
if (newGenre != null)
{
item.Tag.Genres = new string[] { newGenre }
}
;
}
private string MediaMetadataHandlerReader()
{
TagLib.File file = TagLib.File.Create(FilePath);
Metadata = file.Tag.Copyright.ToString();
return(Metadata);
}
private void FillInTheTag(TagLib.File tagFile)
{
var tag = tagFile.Tag;
Creator = tag.FirstPerformer;
Title = tag.Title;
Duration = tagFile.Properties.Duration.Milliseconds;
}
public FileEntryClass(string file)
{
TagLib.File audiofile = TagLib.File.Create(file);
Tag = audiofile.Tag;
filename = Path.GetFileName(file);
filepath = file;
duration = audiofile.Properties.Duration;
}
private static string GetTitle(TagLib.File tagFile)
{
if (!string.IsNullOrEmpty(tagFile.Tag.Title))
{
return(tagFile.Tag.Title);
}
return(tagFile.Name);
}
public void CheckJpegComment(File file, int i)
{
var tag = file.GetTag(TagTypes.JpegComment) as JpegCommentTag;
Assert.IsNotNull(tag, $"JpegTag Tag not contained: index {i}");
Assert.AreEqual("Created with GIMP", tag.Comment, $"index {i}");
}
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);
}
}
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,
};
}));
}
private static void ResizeWithGraphicsMagick(ResizeOptions options, File originalTags)
{
var newSize = ComputeNewImageSize(options, originalTags);
string exePath;
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
var pathCodeBase = Assembly.GetExecutingAssembly().CodeBase.Substring(8); // strip leading "file:///"
Console.WriteLine("DEBUG: pathCodeBase={0}", pathCodeBase);
exePath = Path.Combine(Path.GetDirectoryName(pathCodeBase), "gm", "gm.exe");
}
else
{
exePath = "/usr/bin/gm";
}
Console.WriteLine("DEBUG: exePath={0}", exePath);
string arguments;
if (originalTags.Properties != null && originalTags.Properties.Description == "PNG File")
{
// Ensure opaque white background and no transparency as well as adjusting the size of the image
arguments =
$"convert \"{options.FileName}\" -background white -extent 0x0 +matte -scale {newSize.Width}x{newSize.Height} \"{options.Output}\"";
}
else
{
arguments =
$"convert \"{options.FileName}\" -scale {newSize.Width}x{newSize.Height} \"{options.Output}\"";
}
Console.WriteLine("DEBUG: arguments={0}", arguments);
var proc = new Process
{
StartInfo =
{
FileName = exePath,
Arguments = arguments,
UseShellExecute = false, // enables CreateNoWindow
CreateNoWindow = true, // don't need a DOS box
RedirectStandardOutput = true,
RedirectStandardError = true,
}
};
proc.Start();
proc.WaitForExit();
var standardOutput = proc.StandardOutput.ReadToEnd();
var standardError = proc.StandardError.ReadToEnd();
Console.WriteLine("GraphicsMagic exit code = {0}", proc.ExitCode);
Console.WriteLine("GraphicsMagic stderr");
Console.WriteLine("--------------------");
Console.WriteLine(standardError);
Console.WriteLine("================================");
Console.WriteLine("GraphicsMagic stdout");
Console.WriteLine("--------------------");
Console.WriteLine(standardOutput);
Console.WriteLine("================================");
}
public static void Write(string path, Track track)
{
AlbumArtFile artworkFile = null;
if (AlbumArtCache.Instance.HasItem(track.Album.CoverUri.ToString()))
{
artworkFile = AlbumArtCache.Instance.Get(track.Album.CoverUri.ToString());
}
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;
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);
}
}
static void FinishEncode()
{
audioStreamComplete = true;
Session.Pause();
Session.UnloadPlayer();
lame.LameSetInSampleRate(staticfmt.sample_rate);
lame.LameSetNumChannels(staticfmt.channels);
lame.LameSetBRate(_confo.lameBitrate);
Log.Debug("Encoding at " + _confo.lameBitrate + "kbps");
lame.LameInitParams();
outStream = outFile.OpenWrite();
short[] left = new short[buf.Length / 4],
right = new short[buf.Length / 4];
byte[] fourbytes = new byte[4];
for (int i = 0; i < buf.Length; i += 4)
{
buf.Read(fourbytes, 0, 4);
left[i / 4] = BitConverter.ToInt16(new byte[2] {
fourbytes[0], fourbytes[1]
}, 0);
right[i / 4] = BitConverter.ToInt16(new byte[2] {
fourbytes[2], fourbytes[3]
}, 0);
}
int outSize = lame.LameEncodeBuffer(left, right, left.Length, mp3Out);
outStream.Write(mp3Out, 0, outSize);
outSize = lame.LameEncodeFlush(mp3Out);
outStream.Write(mp3Out, 0, outSize);
outStream.Flush();
outStream.Close();
Log.Debug("File written to disk! Trying to write tags...");
TagLib.File tf = TagLib.File.Create(outFile.FullName);
tf.Tag.Album = _album;
tf.Tag.AlbumArtists = null;
tf.Tag.AlbumArtists = new string[1] {
_artist
};
tf.Tag.Title = _song;
tf.Tag.Performers = null;
tf.Tag.Performers = new string[1] {
_artist
};
tf.Tag.Artists = null;
tf.Tag.Artists = new string[1] {
_artist
};
tf.Save();
Log.Debug("Tags written! Finished!");
if (frm != null)
{
frm.BeginInvoke((Delegate) new MethodInvoker(() => frm.SetStatus("Download finished")));
}
new SftpUploader(_confo).go(outFile.FullName);
}
public void writeCommentinFile(List <string> listFile)
{
for (int i = 0; i < listFile.Count(); i++)
{
TagLib.File File = TagLib.File.Create(listFile[i]);
File.Tag.Comment = i.ToString(); //access comment section in file
File.Save();
}
}
public MusicFile(string path)
{
string extension = System.IO.Path.GetExtension(path);
if (extension == null || !_musicExtensions.Contains(extension.ToLower()))
throw new UnsupportedFormatException();
_file = File.Create(path);
Path = path;
}
private int RecursiveTraversal(string path, int fileIndex)
{
//System.Threading.Thread.Sleep(5000);
int step = 0;
var childDirs = SortedSubDirectories(path);
if (childDirs.Length == 0)
{
var files = Directory.GetFiles(path);
if (files.Length > 1)
{
return(-999);
}
int index = 0;
int maxIndex = 0;
foreach (var file in files)
{
maxIndex = fileIndex + index++;
var destination = Directory.GetParent(path).FullName + "\\" + RoundIndexToTwoPlaces(maxIndex) + Path.GetExtension(file);
if (!System.IO.File.Exists(destination))
{
System.IO.File.Move(file, destination);
if (ItWasNotAlreadySortedBefore(file))
{
TagLib.File tFile = TagLib.File.Create(destination);
tFile.Tag.Title = "";
tFile.Save();
}
}
}
if (Directory.GetFiles(path).Length == 0)
{
Directory.Delete(path);
}
return(++maxIndex);
}
else
{
foreach (var dir in childDirs)
{
var maxIndex = RecursiveTraversal(dir, step);
if (maxIndex == -999)
{
break;
}
step = maxIndex;
}
}
return(step);
}
public void Init()
{
files = new File[count];
for (int i = 0; i < count; i++)
{
files[i] = File.Create(GetSampleFilename(i));
}
}
public void SetValues(string fileInfo)
{
if (System.IO.File.Exists(fileInfo))
{
_isMulti = false;
_file = File.Create(fileInfo);
SetValues();
}
}
public get_details(string path)
{
try
{
if (path != "")
file = TagLib.File.Create(path);
}
catch { }
}
private void setImage(ref TagLib.File tgFile)
{
if (tgFile.Tag.Pictures.Length > 0)
{
image = Path.Combine(Resources.imagesDirectory, name);
var pixmap = Image.FromStream(new MemoryStream(tgFile.Tag.Pictures[0].Data.Data));
pixmap.Save(image, ImageFormat.Png);
}
}
private async Task ReadTags(TagLib.File tagFile)
{
Tag tags = tagFile.GetTag(TagTypes.Id3v2);
Title = tags.Title;
Artsit = tags.Performers.FirstOrDefault();
Album = tags.Album;
Cover = await tags.Pictures[0].ToBitmapImage(new Size(120, 120));
}
public Picture(File.IFileAbstraction abstraction)
{
if (abstraction == null)
{
throw new ArgumentNullException("abstraction");
}
this.Data = ByteVector.FromFile(abstraction);
this.FillInMimeFromData();
this.Description = abstraction.Name;
}
public static void Clean()
{
try
{
ChannelProps.Clear();
fileTag = null;
}
catch (Exception)
{
}
}
public FileParser(TagLib.File file)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
this.file = file;
this.first_header = new BoxHeader(file, 0L);
if (this.first_header.BoxType != "ftyp")
{
throw new CorruptFileException("File does not start with 'ftyp' box.");
}
}
private TagLib.File m_TagLibFile; // TagLibSharp file object
#endregion Fields
#region Constructors
/// <summary>
/// Constructor
/// </summary>
/// <param name="Filename">
/// A <see cref="System.String"/> containing the path to the Ogg Vorbis file this instance represents
/// </param>
public OggFile(string Filename)
{
// Check that the file exists
if (!(System.IO.File.Exists(Filename))) { throw new OggFileReadException("File not found", Filename); }
// Load the relevant objects
m_Filename = Filename;
try
{
m_CSVorbisFile = new VorbisFile(m_Filename);
}
catch (Exception ex)
{
throw new OggFileReadException("Unable to open file for data reading\n" + ex.Message, Filename);
}
try
{
m_TagLibFile = TagLib.File.Create(m_Filename);
}
catch (TagLib.UnsupportedFormatException ex)
{
throw new OggFileReadException("Unsupported format (not an ogg?)\n" + ex.Message, Filename);
}
catch (TagLib.CorruptFileException ex)
{
throw new OggFileCorruptException(ex.Message, Filename, "Tags");
}
// Populate some other info shizzle and do a little bit of sanity checking
m_Streams = m_CSVorbisFile.streams();
if (m_Streams<=0) { throw new OggFileReadException("File doesn't contain any logical bitstreams", Filename); }
// Assuming <0 is for whole file and >=0 is for specific logical bitstreams
m_Bitrate = m_CSVorbisFile.bitrate(-1);
m_LengthTime = (int)m_CSVorbisFile.time_total(-1);
// Figure out the ALFormat of the stream
m_Info = m_CSVorbisFile.getInfo(); // Get the info of the first stream, assuming all streams are the same? Dunno if this is safe tbh
if (m_Info[0] == null) { throw new OggFileReadException("Unable to determine Format{FileInfo.Channels} for first bitstream", Filename); }
if (m_TagLibFile.Properties.AudioBitrate==16) {
m_Format = (m_Info[0].channels)==1 ? ALFormat.Mono16 : ALFormat.Stereo16; // This looks like a fudge, but I've seen it a couple of times (what about the other formats I wonder?)
}
else
{
m_Format = (m_Info[0].channels)==1 ? ALFormat.Mono8 : ALFormat.Stereo8;
}
// A grab our first instance of the file so we're ready to play
m_CSVorbisFileInstance = m_CSVorbisFile.makeInstance();
}
public void initialize(Song song)
{
if (song.usingTagLib) {
metaFile = song.tagFile;
this.Text = song.ToString();
textBox_Title.Text = metaFile.Tag.Title;
textBox_Artist.Text = metaFile.Tag.FirstPerformer;
if (metaFile.Tag.Genres.Length > 0)
textBox_Genre.Text = metaFile.Tag.Genres[0];
foreach (String genre in metaFile.Tag.Genres)
textBox_Genre.Text += "; " + genre;
textBox_Album.Text = metaFile.Tag.Album;
textBox_Year.Text = "" + metaFile.Tag.Year;
textBox_Comments.Text = metaFile.Tag.Comment;
button_SaveChanges.Enabled = true;
} else if (song.usingId3Tag && !song.fileCorrupted) {
id3Tag = song.id3Tag;
this.Text = song.ToString();
textBox_Title.Text = id3Tag.Title.Value;
textBox_Artist.Text = id3Tag.Artists.Value;
textBox_Genre.Text = id3Tag.Genre.Value;
textBox_Album.Text = id3Tag.Album.Value;
textBox_Year.Text = "" + id3Tag.Year.Value;
foreach (CommentFrame comment in id3Tag.Comments)
textBox_Comments.Text += comment.Comment + "\n";
button_SaveChanges.Enabled = true;
} else {
//initialized = false;
textBox_Title.Text = null;
textBox_Artist.Text = null;
textBox_Genre.Text = null;
textBox_Album.Text = null;
textBox_Year.Text = null;
textBox_Comments.Text = null;
button_SaveChanges.Enabled = false;
}
}
void PopulateFromId3v2(File file, Tag tag)
{
if (!file.TagTypes.HasFlag(TagTypes.Id3v2))
return;
var id3v2 = (TagLib.Id3v2.Tag)file.GetTag(TagTypes.Id3v2);
tag.ImageData = GetImageData(id3v2);
// ID3v2 Tags Reference: http://id3.org/id3v2.4.0-frames
tag.InitialKey = GetTextFrame(id3v2, "TKEY") ?? GetUserTextFrame(id3v2, "Initial key");
tag.Artist = JoinPerformers(id3v2.Performers);
tag.Title = id3v2.Title;
tag.Year = ToStringOrDefault(id3v2.Year);
tag.Genre = id3v2.JoinedGenres;
tag.Publisher = GetTextFrame(id3v2, "TPUB") ?? GetUserTextFrame(id3v2, "Publisher");
tag.Bpm = ToStringOrDefault(id3v2.BeatsPerMinute) ?? GetUserTextFrame(id3v2, "BPM (beats per minute)");
}
public void ReadTags(string filePath)
{
ChannelProps.Clear();
fileTag = TagLib.File.Create(filePath);
ChannelProps.Add(((double)fileTag.Properties.AudioSampleRate/1000).ToString());
ChannelProps.Add(fileTag.Properties.AudioBitrate.ToString());
ChannelProps.Add(fileTag.Properties.AudioChannels.ToString());
ChannelProps.Add(String.Format("{0:D2}:{1:D2}:{2:D2}", (int)fileTag.Properties.Duration.TotalHours,
fileTag.Properties.Duration.Minutes, fileTag.Properties.Duration.Seconds));
TagLib.Id3v1.Tag id3v1 = fileTag.GetTag(TagLib.TagTypes.Id3v1) as TagLib.Id3v1.Tag;
TagLib.Id3v2.Tag id3v2 = fileTag.GetTag(TagLib.TagTypes.Id3v2) as TagLib.Id3v2.Tag;
TagLib.Mpeg4.AppleTag apple = fileTag.GetTag(TagLib.TagTypes.Apple) as TagLib.Mpeg4.AppleTag;
TagLib.Ape.Tag ape = fileTag.GetTag(TagLib.TagTypes.Ape) as TagLib.Ape.Tag;
TagLib.Asf.Tag asf = fileTag.GetTag(TagLib.TagTypes.Asf) as TagLib.Asf.Tag;
TagLib.Ogg.XiphComment ogg = fileTag.GetTag(TagLib.TagTypes.Xiph) as TagLib.Ogg.XiphComment;
}
public Tag(File file, long position)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
file.Mode = File.AccessMode.Read;
if ((position < 0L) || (position > (file.Length - 0x80L)))
{
throw new ArgumentOutOfRangeException("position");
}
file.Seek(position);
ByteVector data = file.ReadBlock(0x80);
if (!data.StartsWith(FileIdentifier))
{
throw new CorruptFileException("ID3v1 data does not start with identifier.");
}
this.Parse(data);
}
private static bool fixup_album_artist(File tagfile)
{
bool perform_save = false;
string [] album_artists = tagfile.Tag.AlbumArtists;
string album_artists_merged = string.Join(",", album_artists);
album_artists_merged = normalizename(album_artists_merged);
string[] contributing_artists = tagfile.Tag.Performers;
string contributing_artists_merged = string.Join(",", contributing_artists);
contributing_artists_merged = normalizename(contributing_artists_merged);
string[] composers = tagfile.Tag.Composers;
string composers_merged = string.Join(",", composers);
composers_merged = normalizename(composers_merged);
if (album_artists_merged=="")
{
string [] new_album_artists = null;
if (contributing_artists_merged!="")
{
new_album_artists = tagfile.Tag.Performers;
}
else if (composers_merged != "")
{
new_album_artists = tagfile.Tag.Composers;
}
if (new_album_artists!=null)
{
Console.WriteLine(" album artist -> \"{0}\"", contributing_artists_merged);
tagfile.Tag.AlbumArtists = tagfile.Tag.Performers;
perform_save = true;
}
}
return perform_save;
}
public EndTag(TagLib.File file)
{
this.file = file;
}
/// <summary>
/// Based on the Options set, use the correct version for ID3
/// Eventually remove V1 or V2 tags, if set in the options
/// </summary>
/// <param name = "File"></param>
public static File FormatID3Tag(File file)
{
if (file.MimeType == "taglib/mp3")
{
Tag id3v2_tag = file.GetTag(TagTypes.Id3v2) as Tag;
if (id3v2_tag != null && Options.MainSettings.ID3V2Version > 0)
id3v2_tag.Version = (byte)Options.MainSettings.ID3V2Version;
// Remove V1 Tags, if checked or "Save V2 only checked"
if (Options.MainSettings.RemoveID3V1 || Options.MainSettings.ID3Version == 2)
file.RemoveTags(TagTypes.Id3v1);
// Remove V2 Tags, if checked or "Save V1 only checked"
if (Options.MainSettings.RemoveID3V2 || Options.MainSettings.ID3Version == 1)
file.RemoveTags(TagTypes.Id3v2);
// Remove V2 Tags, if Ape checked
if (Options.MainSettings.ID3V2Version == 0)
{
file.RemoveTags(TagTypes.Id3v2);
}
else
{
file.RemoveTags(TagTypes.Ape);
}
}
return file;
}
public void Init()
{
file = File.Create (sample24unsynchronization_file);
}
public static Picture CreateFromFile (File.IFileAbstraction abstraction)
{
return new Picture (abstraction);
}
public ZuneWMATagContainer(File file)
: base(file)
{
_file = file;
_tag = (Tag)file.GetTag(TagTypes.Asf);
}
/// <summary>
/// Reset the OggFile (reload from disk).
/// Useful if tags have changed externally, or to reset the internal position pointer to replay the file from the beginning
/// SeekToTime(0) is the preferred method of moving the internal pointer to the beginning however however
/// </summary>
public void ResetFile()
{
try
{
// Grab a fresh instance of the file
m_CSVorbisFileInstance = m_CSVorbisFile.makeInstance();
m_TagLibFile = null;
m_TagLibFile = TagLib.File.Create(m_Filename);
}
catch (Exception ex)
{
throw new Exception("Unable to reload OggFile [" + m_Filename + "]", ex);
}
}
public void Dispose()
{
m_TagLibFile.Dispose();
m_TagLibFile = null;
m_CSVorbisFile.Dispose();
m_CSVorbisFile = null;
}
/// <summary>
/// Adds the song to the database
/// </summary>
/// <param name = "file"></param>
private void AddSong(File file)
{
string artist = "";
string[] artists = file.Tag.Performers;
if (artists.Length > 0)
{
artist = FormatMultipleEntry(string.Join(";", artists));
}
string albumartist = "";
string[] albumartists = file.Tag.AlbumArtists;
if (albumartists.Length > 0)
{
albumartist = FormatMultipleEntry(string.Join(";", albumartists));
}
string genre = "";
string[] genres = file.Tag.Genres;
if (genres.Length > 0)
{
genre = FormatMultipleEntry(string.Join(";", genres));
}
string title = file.Tag.Title == null ? "" : file.Tag.Title.Trim();
string sql =
String.Format(
@"insert into tracks (strPath, strArtist, strAlbumArtist, strAlbum, strGenre, strTitle, iTrack, iNumTracks, iYear, iRating, iDisc, iNumDisc, strLyrics)
values ('{0}', '{1}', '{2}', '{3}', '{4}', '{5}', {6}, {7}, {8}, {9}, {10}, {11}, '{12}' )",
Util.RemoveInvalidChars(file.Name), Util.RemoveInvalidChars(artist), Util.RemoveInvalidChars(albumartist),
Util.RemoveInvalidChars(file.Tag.Album), Util.RemoveInvalidChars(genre), Util.RemoveInvalidChars(title),
file.Tag.Track, file.Tag.TrackCount, file.Tag.Year, 0,
file.Tag.Disc, file.Tag.DiscCount, "");
ExecuteDirectSQL(sql);
AddArtist(Util.RemoveInvalidChars(artist));
AddAlbumArtist(Util.RemoveInvalidChars(albumartist));
AddGenre(Util.RemoveInvalidChars(genre));
}
public void SetValues(string fileInfo)
{
if (System.IO.File.Exists(fileInfo))
{
_isMulti = false;
_file = File.Create(fileInfo);
SetValues();
}
}
private File SaveToFile(File file, Tag tag)
{
if (Id3Handler.Save(file, _file))
{
if (checkBoxRename.Checked)
{
var filename =
Helper.RenameFile(new BaseInfoTag(tag.JoinedPerformers, tag.FirstPerformer, tag.Album,
tag.Title,
_file.Name));
if (filename != Actiontype.Exception.ToString() &&
filename != Actiontype.Already.ToString())
return File.Create(filename);
}
return file;
}
return null;
}
public TestFile(File.IFileAbstraction abstraction)
: base(abstraction)
{
}
public void Init()
{
file = File.Create("samples/sample_both.mp3");
}
//private SongInfo GetLyricsAndSongInfoByVK(File audioFile, string fileName)
//{
// var authorize = new VkAuthorization();
// var api = authorize.Authorize();
// var songLyricsAndInfoGetter = new IVkAudioService(api);
// var titleEncoded = audioFile.Tag.Title.ToUtf8();
// var artistEncoded = audioFile.Tag.Artists.ConvertStringArrayToString().ToUtf8();
// if (string.IsNullOrEmpty(titleEncoded) == false)
// {
// var info = songLyricsAndInfoGetter.GetSongInfo(artistEncoded + " " + titleEncoded);
// if (info != null)
// {
// return info;
// }
// }
// if (string.IsNullOrEmpty(fileName) == false)
// {
// var info = songLyricsAndInfoGetter.GetSongInfo(fileName);
// if (info != null)
// {
// return info;
// }
// }
// return null;
//}
private string SongAlbumPicturePathToDb(File audioFile, string saveSongCoverPath, string songId,
string songAlbumPicturePathToDb, string titleVk, string artistVk, string filename, ref string content)
{
if (audioFile.Tag.Pictures.Any())
{
SongPictureGetter.GetAndSavePictureByTag(audioFile.Tag, saveSongCoverPath, songId);
}
else
{
var trackInfo = SongPictureGetter.GetPictureByWebService(audioFile.Tag, titleVk, artistVk, filename);
if (trackInfo != null)
{
songAlbumPicturePathToDb = trackInfo.PicturePath;
content = trackInfo.Content;
}
}
return songAlbumPicturePathToDb;
}
public void Init()
{
file = File.Create(sample_file);
}
private static bool fixup_title(string filename, File tagfile)
{
bool perform_save = false;
string title = tagfile.Tag.Title;
if (novalue(title))
{
string newtitle = System.IO.Path.GetFileNameWithoutExtension(filename);
tagfile.Tag.Title = newtitle;
perform_save = true;
Console.WriteLine(" title -> \"{0}\"", newtitle);
}
return perform_save;
}
