jellyfin-server/MediaBrowser.Providers/MediaInfo/FFProbeAudioInfoProvider.cs

260 lines
9.2 KiB
C#
Raw Normal View History

using MediaBrowser.Common.MediaInfo;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Controller.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
2013-02-21 01:33:05 +00:00
2013-06-09 16:47:28 +00:00
namespace MediaBrowser.Providers.MediaInfo
2013-02-21 01:33:05 +00:00
{
/// <summary>
/// Extracts audio information using ffprobe
/// </summary>
public class FFProbeAudioInfoProvider : BaseFFProbeProvider<Audio>
{
2013-04-07 22:09:48 +00:00
public FFProbeAudioInfoProvider(ILogManager logManager, IServerConfigurationManager configurationManager, IMediaEncoder mediaEncoder, IJsonSerializer jsonSerializer)
: base(logManager, configurationManager, mediaEncoder, jsonSerializer)
2013-03-02 17:59:15 +00:00
{
}
2013-06-18 19:16:27 +00:00
public override async Task<bool> FetchAsync(BaseItem item, bool force, CancellationToken cancellationToken)
{
var myItem = (Audio)item;
OnPreFetch(myItem, null);
var result = await GetMediaInfo(item, null, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
NormalizeFFProbeResult(result);
cancellationToken.ThrowIfCancellationRequested();
Fetch(myItem, cancellationToken, result);
SetLastRefreshed(item, DateTime.UtcNow);
return true;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Fetches the specified audio.
/// </summary>
/// <param name="audio">The audio.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="data">The data.</param>
/// <param name="isoMount">The iso mount.</param>
/// <returns>Task.</returns>
2013-06-18 19:16:27 +00:00
protected void Fetch(Audio audio, CancellationToken cancellationToken, MediaInfoResult data)
2013-02-21 01:33:05 +00:00
{
if (data.streams == null)
2013-02-21 01:33:05 +00:00
{
Logger.Error("Audio item has no streams: " + audio.Path);
return;
}
2013-02-21 01:33:05 +00:00
2013-04-29 15:06:31 +00:00
audio.MediaStreams = data.streams.Select(s => GetMediaStream(s, data.format))
.Where(i => i != null)
.ToList();
2013-02-21 01:33:05 +00:00
// Get the first audio stream
var stream = data.streams.FirstOrDefault(s => s.codec_type.Equals("audio", StringComparison.OrdinalIgnoreCase));
2013-02-21 01:33:05 +00:00
if (stream != null)
{
// Get duration from stream properties
var duration = stream.duration;
2013-02-21 01:33:05 +00:00
// If it's not there go into format properties
if (string.IsNullOrEmpty(duration))
{
duration = data.format.duration;
}
// If we got something, parse it
if (!string.IsNullOrEmpty(duration))
{
audio.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(duration, UsCulture)).Ticks;
}
}
2013-02-21 01:33:05 +00:00
if (data.format.tags != null)
{
FetchDataFromTags(audio, data.format.tags);
}
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Fetches data from the tags dictionary
/// </summary>
/// <param name="audio">The audio.</param>
/// <param name="tags">The tags.</param>
private void FetchDataFromTags(Audio audio, Dictionary<string, string> tags)
{
var title = GetDictionaryValue(tags, "title");
// Only set Name if title was found in the dictionary
if (!string.IsNullOrEmpty(title))
{
audio.Name = title;
}
2013-08-04 00:59:23 +00:00
if (!audio.LockedFields.Contains(MetadataFields.Cast))
2013-02-21 01:33:05 +00:00
{
2013-08-29 21:00:27 +00:00
audio.People.Clear();
2013-08-04 00:59:23 +00:00
var composer = GetDictionaryValue(tags, "composer");
2013-02-21 01:33:05 +00:00
2013-08-04 00:59:23 +00:00
if (!string.IsNullOrWhiteSpace(composer))
{
foreach (var person in Split(composer))
2013-02-21 01:33:05 +00:00
{
2013-08-04 00:59:23 +00:00
var name = person.Trim();
if (!string.IsNullOrEmpty(name))
{
audio.AddPerson(new PersonInfo { Name = name, Type = PersonType.Composer });
}
2013-02-21 01:33:05 +00:00
}
}
}
audio.Album = GetDictionaryValue(tags, "album");
2013-04-23 03:56:11 +00:00
audio.Artist = GetDictionaryValue(tags, "artist");
2013-02-21 01:33:05 +00:00
// Several different forms of albumartist
audio.AlbumArtist = GetDictionaryValue(tags, "albumartist") ?? GetDictionaryValue(tags, "album artist") ?? GetDictionaryValue(tags, "album_artist");
// Track number
audio.IndexNumber = GetDictionaryNumericValue(tags, "track");
// Disc number
audio.ParentIndexNumber = GetDictionaryDiscValue(tags);
audio.Language = GetDictionaryValue(tags, "language");
audio.ProductionYear = GetDictionaryNumericValue(tags, "date");
// Several different forms of retaildate
audio.PremiereDate = GetDictionaryDateTime(tags, "retaildate") ?? GetDictionaryDateTime(tags, "retail date") ?? GetDictionaryDateTime(tags, "retail_date");
// If we don't have a ProductionYear try and get it from PremiereDate
if (audio.PremiereDate.HasValue && !audio.ProductionYear.HasValue)
{
2013-04-12 18:22:40 +00:00
audio.ProductionYear = audio.PremiereDate.Value.ToLocalTime().Year;
2013-02-21 01:33:05 +00:00
}
2013-08-04 00:59:23 +00:00
if (!audio.LockedFields.Contains(MetadataFields.Genres))
{
FetchGenres(audio, tags);
}
2013-02-21 01:33:05 +00:00
2013-08-04 00:59:23 +00:00
if (!audio.LockedFields.Contains(MetadataFields.Studios))
{
// There's several values in tags may or may not be present
FetchStudios(audio, tags, "organization");
FetchStudios(audio, tags, "ensemble");
FetchStudios(audio, tags, "publisher");
}
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Splits the specified val.
/// </summary>
/// <param name="val">The val.</param>
/// <returns>System.String[][].</returns>
private IEnumerable<string> Split(string val)
{
// Only use the comma as a delimeter if there are no slashes or pipes.
// We want to be careful not to split names that have commas in them
var delimeter = val.IndexOf('/') == -1 && val.IndexOf('|') == -1 ? new[] { ',' } : new[] { '/', '|' };
return val.Split(delimeter, StringSplitOptions.RemoveEmptyEntries);
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the studios from the tags collection
/// </summary>
/// <param name="audio">The audio.</param>
/// <param name="tags">The tags.</param>
/// <param name="tagName">Name of the tag.</param>
private void FetchStudios(Audio audio, Dictionary<string, string> tags, string tagName)
{
var val = GetDictionaryValue(tags, tagName);
if (!string.IsNullOrEmpty(val))
{
2013-06-11 16:10:41 +00:00
// Sometimes the artist name is listed here, account for that
2013-04-27 13:05:33 +00:00
var studios =
2013-04-29 15:06:31 +00:00
val.Split(new[] { '/', '|' }, StringSplitOptions.RemoveEmptyEntries)
2013-06-11 16:10:41 +00:00
.Where(i => !string.IsNullOrWhiteSpace(i))
.Where(i => !string.Equals(i, audio.Artist, StringComparison.OrdinalIgnoreCase) && !string.Equals(i, audio.AlbumArtist, StringComparison.OrdinalIgnoreCase));
2013-04-27 13:05:33 +00:00
audio.Studios.Clear();
foreach (var studio in studios)
{
2013-06-11 16:10:41 +00:00
// Account for sloppy tags by trimming
audio.AddStudio(studio.Trim());
}
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Gets the genres from the tags collection
/// </summary>
/// <param name="audio">The audio.</param>
/// <param name="tags">The tags.</param>
private void FetchGenres(Audio audio, Dictionary<string, string> tags)
{
var val = GetDictionaryValue(tags, "genre");
if (!string.IsNullOrEmpty(val))
{
audio.Genres.Clear();
2013-05-20 15:37:07 +00:00
foreach (var genre in val
.Split(new[] { '/', '|' }, StringSplitOptions.RemoveEmptyEntries)
.Where(i => !string.IsNullOrWhiteSpace(i)))
{
2013-06-11 16:10:41 +00:00
// Account for sloppy tags by trimming
audio.AddGenre(genre.Trim());
}
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Gets the disc number, which is sometimes can be in the form of '1', or '1/3'
/// </summary>
/// <param name="tags">The tags.</param>
/// <returns>System.Nullable{System.Int32}.</returns>
private int? GetDictionaryDiscValue(Dictionary<string, string> tags)
{
var disc = GetDictionaryValue(tags, "disc");
if (!string.IsNullOrEmpty(disc))
{
disc = disc.Split('/')[0];
int num;
if (int.TryParse(disc, out num))
{
return num;
}
}
return null;
}
}
}