/// <summary>
/// Reset.
/// </summary>
private void Uninit()
{
lock (_syncLock) {
if (_reader != null)
{
_reader.Close();
_reader = null;
}
}
}
public TagCloudRunner(ICloudVisualizer visualizer, ITagReader tagReader, IWordFilter wordFilter, ITextReader wordReader, string pathToWords, string pathToPicture, ImageFormat format)
{
this.visualizer = visualizer;
this.tagReader = tagReader;
this.wordFilter = wordFilter;
this.wordReader = wordReader;
this.pathToWords = pathToWords;
this.pathToPicture = pathToPicture;
this.format = format;
}
private void Uninit()
{
lock (this._syncLock)
{
if (this._reader != null)
{
this._reader.Close();
this._reader = null;
}
}
}
private void Init()
{
IStreamableFileService service = ((IStreamableFileFactory)ScopeUtils.GetScopeService(this._scope, typeof(IStreamableFileFactory))).GetService(this._file);
if (service == null)
{
log.Error("No service found for " + this._file.FullName);
}
else
{
this._reader = service.GetStreamableFile(this._file).GetReader();
if (this._start > 0)
{
this.Seek(this._start);
}
}
}
/// <summary>
/// Returns stream length. Method added to get flv player to work.
/// </summary>
/// <param name="name">Stream name.</param>
/// <returns>Returns the length of a stream, in seconds.</returns>
public double getStreamLength(string name)
{
double duration = 0;
IProviderService provider = ScopeUtils.GetScopeService(this.Scope, typeof(IProviderService)) as IProviderService;
FileInfo file = provider.GetVODProviderFile(this.Scope, name);
if (file != null)
{
IStreamableFileFactory factory = (IStreamableFileFactory)ScopeUtils.GetScopeService(this.Scope, typeof(IStreamableFileFactory)) as IStreamableFileFactory;
IStreamableFileService service = factory.GetService(file);
if (service != null)
{
ITagReader reader = null;
try
{
IStreamableFile streamFile = service.GetStreamableFile(file);
reader = streamFile.GetReader();
duration = (double)reader.Duration / 1000;
}
catch (IOException ex)
{
if (log.IsErrorEnabled)
{
log.Error(string.Format("Error reading stream file {0}. {1}", file.FullName, ex.Message));
}
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
else
{
if (log.IsErrorEnabled)
{
log.Error(string.Format("No service found for {0}", file.FullName));
}
}
file = null;
}
return(duration);
}
/// <summary>
/// Initializes file provider. Creates streamable file factory and service, seeks to start position.
/// </summary>
private void Init()
{
IStreamableFileFactory factory = (IStreamableFileFactory)ScopeUtils.GetScopeService(_scope, typeof(IStreamableFileFactory));
IStreamableFileService service = factory.GetService(_file);
if (service == null)
{
log.Error("No service found for " + _file.FullName);
return;
}
IStreamableFile streamFile = service.GetStreamableFile(_file);
_reader = streamFile.GetReader();
if (_start > 0)
{
Seek(_start);
}
}
/// <summary>Reads the nbt's content from the <see cref="Stream"/></summary>
/// <param name="tag">The tag to read from the <see cref="Stream"/></param>
/// <param name="Context">The context to read from</param>
public void ReadContent(ITag tag, SerializationContext Context)
{
ITag SubTag;
Object O = tag.GetInformation(NBTTagInformation.ListSubtype);
if (O == null)
{
throw new Exception("List returned no subtype");
}
var SubTagType = (NBTTagType)O;
ITagReader Reader = NBTReader.GetReader(SubTagType);
if (Reader == null)
{
throw new Exception($"No reader for type: {SubTagType}");
}
if (SubTagType == NBTTagType.List)
{
for (Int32 I = 0; I < tag.Count; I++)
{
SubTag = new NBTTagList(SubTagType);
SubTag.SetInformation(NBTTagInformation.ListSubtype, (NBTTagType)Context.Stream.ReadByte());
SubTag.SetInformation(NBTTagInformation.ListSize, Context.ReadInt32());
Reader.ReadContent(SubTag, Context);
tag[I] = SubTag;
}
}
else
{
for (Int32 I = 0; I < tag.Count; I++)
{
SubTag = NBTTagFactory.Create(SubTagType);
tag[I] = SubTag;
Reader.ReadContent(SubTag, Context);
}
}
}
private void AddTreeNode(ITagReader tag, TreeNode tn)
{
var parent = tag as ITagReader;
if (parent != null)
{
var actions = parent.GetActions();
if (actions != null)
{
foreach (var item in actions)
{
TreeNode node = new TreeNode(item);
tn.Nodes.Add(node);
if (_dict.ContainsKey(GetFullPath(node)))
{
node.Checked = true;
}
}
}
if (parent.Children != null)
{
foreach (ITagReader child in parent.Children)
{
TreeNode node = new TreeNode(child.Node);
tn.Nodes.Add(node);
string path = GetFullPath(node);
if (_dict.ContainsKey(path))
{
node.Checked = true;
}
//递归调用
AddTreeNode(child, node);
}
}
}
}
/// <summary>
/// Reset.
/// </summary>
private void Uninit()
{
lock (_syncLock)
{
if (_reader != null)
{
_reader.Close();
_reader = null;
}
}
}
/// <summary>
/// Initializes file provider. Creates streamable file factory and service, seeks to start position.
/// </summary>
private void Init()
{
IStreamableFileFactory factory = (IStreamableFileFactory)ScopeUtils.GetScopeService(_scope, typeof(IStreamableFileFactory));
IStreamableFileService service = factory.GetService(_file);
if (service == null)
{
log.Error("No service found for " + _file.FullName);
return;
}
IStreamableFile streamFile = service.GetStreamableFile(_file);
_reader = streamFile.GetReader();
if (_start > 0)
Seek(_start);
}
public async Task <Track> TagReaderToTrackModelAsync(Guid userId, ITagReader tagReader, Guid collectionId, CancellationToken cancellationToken)
{
var albumArtists = tagReader.AlbumArtists;
var trackArtists = tagReader.Artists;
if (albumArtists?.Any() != true)
{
if (trackArtists?.Any() == true)
{
albumArtists = trackArtists;
}
else
{
albumArtists = new[] { Path.GetDirectoryName(Path.GetDirectoryName(tagReader.Path)) };
}
}
var albumMediaBundle = await GetAlbumAsync(userId, albumArtists, tagReader.AlbumName, collectionId, false, cancellationToken).ConfigureAwait(false);
var track = albumMediaBundle == null ? new Track() : new Track(albumMediaBundle.Media);
var artists = await GetArtistsFromListAsync(userId, tagReader.Artists, collectionId, cancellationToken).ConfigureAwait(false);
if (artists?.Count > 0)
{
var artistMediaBundles = artists.Select(artist => new MediaBundle <Artist>
{
Media = artist
}).ToList();
track.Artists = new HashSet <MediaBundle <Artist> >(artistMediaBundles);
}
else
{
track.Artists = new HashSet <MediaBundle <Artist> >();
}
track.Comment = tagReader.Comment;
track.DateAdded = DateTime.UtcNow;
track.DiscNumber = (int)tagReader.DiscNumber;
track.DateFileCreated = tagReader.DateCreated;
track.DateFileModified = tagReader.DateModified;
track.FileHash = tagReader.Hash;
track.HashType = tagReader.HashType;
track.Path = tagReader.Path;
track.Size = tagReader.Size;
if (tagReader.CoverArt.Any())
{
track.CoverArt = new HashSet <CoverArt>();
}
foreach (var coverArt in tagReader.CoverArt)
{
coverArt.MediaId = track.Id;
track.CoverArt.Add(coverArt);
}
var genres = await GetGenresFromListAsync(tagReader.Genres, collectionId, cancellationToken).ConfigureAwait(false);
if (genres?.Count > 0)
{
track.Genres = new HashSet <Genre>(genres);
}
else
{
track.Genres = new HashSet <Genre>();
}
track.Number = (int)tagReader.TrackNumber;
var composers = await GetArtistsFromListAsync(userId, tagReader.Composers, collectionId, cancellationToken).ConfigureAwait(false);
if (composers?.Count > 0)
{
var composerMediaBundles = composers.Select(composer => new MediaBundle <Artist>
{
Media = composer
}).ToList();
track.WrittenBy = new HashSet <MediaBundle <Artist> >(composerMediaBundles);
}
else
{
track.WrittenBy = new HashSet <MediaBundle <Artist> >();
}
track.Duration = tagReader.Duration;
track.Bitrate = tagReader.Bitrate;
track.Channels = tagReader.Channels;
track.ContentType = tagReader.ContentType;
track.SampleRate = tagReader.SampleRate;
track.Name = tagReader.TrackName;
track.ReleaseDate = (int)tagReader.ReleaseDate;
track.AlbumGain = double.IsNaN(tagReader.ReplayGainAlbumGain) ? (double?)null : tagReader.ReplayGainAlbumGain;
track.AlbumPeak = double.IsNaN(tagReader.ReplayGainAlbumPeak) ? (double?)null : tagReader.ReplayGainAlbumPeak;
track.TrackGain = double.IsNaN(tagReader.ReplayGainTrackGain) ? (double?)null : tagReader.ReplayGainTrackGain;
track.TrackPeak = double.IsNaN(tagReader.ReplayGainTrackPeak) ? (double?)null : tagReader.ReplayGainTrackPeak;
return(track);
}
public TagComplexEditor(ITagReader tag)
{
InitializeComponent();
_tag = tag;
}
public EnglishTextParser(ITagReader tagReader)
{
this.tagReader = tagReader;
}
public TrackFactory(ITagReader tagReader, ITagReader fallbackTagReader)
{
_tagReader = tagReader;
_fallbackTagReader = fallbackTagReader;
}
public TrackFactory(ITagReader tagReader, ITagReader fallbackTagReader)
{
_tagReader = tagReader;
_fallbackTagReader = fallbackTagReader;
}
