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

407 lines
15 KiB
C#
Raw Normal View History

2014-02-09 21:11:11 +00:00
using MediaBrowser.Common.Configuration;
using MediaBrowser.Common.Extensions;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Library;
2014-02-20 16:37:41 +00:00
using MediaBrowser.Controller.MediaEncoding;
2013-12-06 03:39:44 +00:00
using MediaBrowser.Controller.Persistence;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.MediaInfo;
2014-02-09 21:11:11 +00:00
using MediaBrowser.Model.Serialization;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Generic;
using System.Globalization;
2014-02-09 21:11:11 +00:00
using System.IO;
2013-02-21 01:33:05 +00:00
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
{
class FFProbeAudioInfo
2013-02-21 01:33:05 +00:00
{
private readonly IMediaEncoder _mediaEncoder;
2013-12-06 03:39:44 +00:00
private readonly IItemRepository _itemRepo;
2014-02-09 21:11:11 +00:00
private readonly IApplicationPaths _appPaths;
private readonly IJsonSerializer _json;
2013-12-06 03:39:44 +00:00
private readonly CultureInfo _usCulture = new CultureInfo("en-US");
2014-02-09 21:11:11 +00:00
public FFProbeAudioInfo(IMediaEncoder mediaEncoder, IItemRepository itemRepo, IApplicationPaths appPaths, IJsonSerializer json)
2013-03-02 17:59:15 +00:00
{
_mediaEncoder = mediaEncoder;
2013-12-06 03:39:44 +00:00
_itemRepo = itemRepo;
2014-02-09 21:11:11 +00:00
_appPaths = appPaths;
_json = json;
2013-03-02 17:59:15 +00:00
}
public async Task<ItemUpdateType> Probe<T>(T item, CancellationToken cancellationToken)
where T : Audio
2013-06-18 19:16:27 +00:00
{
var result = await GetMediaInfo(item, cancellationToken).ConfigureAwait(false);
2013-06-18 19:16:27 +00:00
cancellationToken.ThrowIfCancellationRequested();
FFProbeHelpers.NormalizeFFProbeResult(result);
2013-06-18 19:16:27 +00:00
cancellationToken.ThrowIfCancellationRequested();
await Fetch(item, cancellationToken, result).ConfigureAwait(false);
2013-06-18 19:16:27 +00:00
return ItemUpdateType.MetadataImport;
}
2013-06-18 19:16:27 +00:00
2014-03-26 21:05:31 +00:00
private const string SchemaVersion = "1";
private async Task<InternalMediaInfoResult> GetMediaInfo(BaseItem item, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
2014-02-09 21:11:11 +00:00
var idString = item.Id.ToString("N");
2014-03-26 21:05:31 +00:00
var cachePath = Path.Combine(_appPaths.CachePath,
"ffprobe-audio",
idString.Substring(0, 2), idString, "v" + SchemaVersion + _mediaEncoder.Version + item.DateModified.Ticks.ToString(_usCulture) + ".json");
2014-02-09 21:11:11 +00:00
try
{
return _json.DeserializeFromFile<InternalMediaInfoResult>(cachePath);
}
catch (FileNotFoundException)
{
}
catch (DirectoryNotFoundException)
{
}
var inputPath = new[] { item.Path };
var result = await _mediaEncoder.GetMediaInfo(inputPath, MediaProtocol.File, false, cancellationToken).ConfigureAwait(false);
2014-02-09 21:11:11 +00:00
Directory.CreateDirectory(Path.GetDirectoryName(cachePath));
_json.SerializeToFile(result, cachePath);
return result;
2013-06-18 19:16:27 +00:00
}
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>
/// <returns>Task.</returns>
2014-01-12 06:31:21 +00:00
protected Task Fetch(Audio audio, CancellationToken cancellationToken, InternalMediaInfoResult data)
2013-02-21 01:33:05 +00:00
{
2014-04-22 17:25:54 +00:00
var mediaInfo = MediaEncoderHelpers.GetMediaInfo(data);
var mediaStreams = mediaInfo.MediaStreams;
2013-02-21 01:33:05 +00:00
2014-04-22 17:25:54 +00:00
audio.FormatName = mediaInfo.Format;
audio.TotalBitrate = mediaInfo.TotalBitrate;
audio.HasEmbeddedImage = mediaStreams.Any(i => i.Type == MediaStreamType.EmbeddedImage);
2013-12-06 03:39:44 +00:00
2014-01-11 23:07:56 +00:00
if (data.streams != null)
{
2014-01-11 23:07:56 +00:00
// Get the first audio stream
var stream = data.streams.FirstOrDefault(s => string.Equals(s.codec_type, "audio", StringComparison.OrdinalIgnoreCase));
2014-01-11 23:07:56 +00:00
if (stream != null)
{
2014-01-11 23:07:56 +00:00
// Get duration from stream properties
var duration = stream.duration;
// 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;
2014-01-11 23:07:56 +00:00
}
}
}
2013-02-21 01:33:05 +00:00
2014-04-18 05:03:01 +00:00
if (data.format != null)
{
2014-04-18 05:03:01 +00:00
var extension = (Path.GetExtension(audio.Path) ?? string.Empty).TrimStart('.');
audio.Container = extension;
if (!string.IsNullOrEmpty(data.format.size))
{
audio.Size = long.Parse(data.format.size , _usCulture);
}
else
{
audio.Size = null;
}
if (data.format.tags != null)
{
FetchDataFromTags(audio, data.format.tags);
}
}
2013-12-06 03:39:44 +00:00
return _itemRepo.SaveMediaStreams(audio.Id, mediaStreams, cancellationToken);
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 = FFProbeHelpers.GetDictionaryValue(tags, "title");
2013-02-21 01:33:05 +00:00
// 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();
var composer = FFProbeHelpers.GetDictionaryValue(tags, "composer");
2013-02-21 01:33:05 +00:00
2013-08-04 00:59:23 +00:00
if (!string.IsNullOrWhiteSpace(composer))
{
2014-03-25 21:13:55 +00:00
foreach (var person in Split(composer, false))
2013-02-21 01:33:05 +00:00
{
2013-09-05 22:59:07 +00:00
audio.AddPerson(new PersonInfo { Name = person, Type = PersonType.Composer });
2013-02-21 01:33:05 +00:00
}
}
}
audio.Album = FFProbeHelpers.GetDictionaryValue(tags, "album");
2013-02-21 01:33:05 +00:00
var artist = FFProbeHelpers.GetDictionaryValue(tags, "artist");
if (string.IsNullOrWhiteSpace(artist))
{
audio.Artists.Clear();
}
else
{
audio.Artists = SplitArtists(artist)
.Distinct(StringComparer.OrdinalIgnoreCase)
.ToList();
}
2013-02-21 01:33:05 +00:00
2014-06-23 16:05:19 +00:00
var albumArtist = FFProbeHelpers.GetDictionaryValue(tags, "albumartist") ?? FFProbeHelpers.GetDictionaryValue(tags, "album artist") ?? FFProbeHelpers.GetDictionaryValue(tags, "album_artist");
if (string.IsNullOrWhiteSpace(albumArtist))
{
audio.AlbumArtists = new List<string>();
}
else
{
audio.AlbumArtists = SplitArtists(albumArtist)
.Distinct(StringComparer.OrdinalIgnoreCase)
.ToList();
}
2013-02-21 01:33:05 +00:00
// Track number
2013-09-08 16:49:05 +00:00
audio.IndexNumber = GetDictionaryDiscValue(tags, "track");
2013-02-21 01:33:05 +00:00
// Disc number
2013-09-08 16:49:05 +00:00
audio.ParentIndexNumber = GetDictionaryDiscValue(tags, "disc");
2013-02-21 01:33:05 +00:00
audio.ProductionYear = FFProbeHelpers.GetDictionaryNumericValue(tags, "date");
2013-02-21 01:33:05 +00:00
// Several different forms of retaildate
2014-02-22 20:20:22 +00:00
audio.PremiereDate = FFProbeHelpers.GetDictionaryDateTime(tags, "retaildate") ??
FFProbeHelpers.GetDictionaryDateTime(tags, "retail date") ??
FFProbeHelpers.GetDictionaryDateTime(tags, "retail_date") ??
FFProbeHelpers.GetDictionaryDateTime(tags, "date");
2013-02-21 01:33:05 +00:00
// 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))
{
audio.Studios.Clear();
2013-08-04 00:59:23 +00:00
// There's several values in tags may or may not be present
FetchStudios(audio, tags, "organization");
FetchStudios(audio, tags, "ensemble");
FetchStudios(audio, tags, "publisher");
}
audio.SetProviderId(MetadataProviders.MusicBrainzAlbumArtist, FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Album Artist Id"));
audio.SetProviderId(MetadataProviders.MusicBrainzArtist, FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Artist Id"));
audio.SetProviderId(MetadataProviders.MusicBrainzAlbum, FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Album Id"));
audio.SetProviderId(MetadataProviders.MusicBrainzReleaseGroup, FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Release Group Id"));
2013-02-21 01:33:05 +00:00
}
private readonly char[] _nameDelimiters = { '/', '|', ';', '\\' };
/// <summary>
/// Splits the specified val.
/// </summary>
/// <param name="val">The val.</param>
2014-03-25 21:13:55 +00:00
/// <param name="allowCommaDelimiter">if set to <c>true</c> [allow comma delimiter].</param>
/// <returns>System.String[][].</returns>
2014-03-25 21:13:55 +00:00
private IEnumerable<string> Split(string val, bool allowCommaDelimiter)
{
// 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
2014-03-25 21:13:55 +00:00
var delimeter = !allowCommaDelimiter || _nameDelimiters.Any(i => val.IndexOf(i) != -1) ?
_nameDelimiters :
new[] { ',' };
return val.Split(delimeter, StringSplitOptions.RemoveEmptyEntries)
.Where(i => !string.IsNullOrWhiteSpace(i))
.Select(i => i.Trim());
}
private const string ArtistReplaceValue = " | ";
private IEnumerable<string> SplitArtists(string val)
{
val = val.Replace(" featuring ", ArtistReplaceValue, StringComparison.OrdinalIgnoreCase)
.Replace(" feat. ", ArtistReplaceValue, StringComparison.OrdinalIgnoreCase);
var artistsFound = new List<string>();
foreach (var whitelistArtist in GetSplitWhitelist())
{
2014-02-09 04:52:52 +00:00
var originalVal = val;
val = val.Replace(whitelistArtist, "|", StringComparison.OrdinalIgnoreCase);
2014-02-09 04:52:52 +00:00
if (!string.Equals(originalVal, val, StringComparison.OrdinalIgnoreCase))
{
artistsFound.Add(whitelistArtist);
}
}
// 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 = _nameDelimiters;
var artists = val.Split(delimeter, StringSplitOptions.RemoveEmptyEntries)
2013-09-05 22:59:07 +00:00
.Where(i => !string.IsNullOrWhiteSpace(i))
.Select(i => i.Trim());
artistsFound.AddRange(artists);
return artistsFound;
}
private List<string> _splitWhiteList = null;
private IEnumerable<string> GetSplitWhitelist()
{
if (_splitWhiteList == null)
{
var file = GetType().Namespace + ".whitelist.txt";
using (var stream = GetType().Assembly.GetManifestResourceStream(file))
{
using (var reader = new StreamReader(stream))
{
var list = new List<string>();
while (!reader.EndOfStream)
{
var val = reader.ReadLine();
if (!string.IsNullOrWhiteSpace(val))
{
list.Add(val);
}
}
_splitWhiteList = list;
}
}
}
return _splitWhiteList;
}
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 = FFProbeHelpers.GetDictionaryValue(tags, tagName);
2013-02-21 01:33:05 +00:00
if (!string.IsNullOrEmpty(val))
{
2013-06-11 16:10:41 +00:00
// Sometimes the artist name is listed here, account for that
2014-03-25 21:13:55 +00:00
var studios = Split(val, true).Where(i => !audio.HasArtist(i));
foreach (var studio in studios)
{
2013-09-05 22:59:07 +00:00
audio.AddStudio(studio);
}
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 = FFProbeHelpers.GetDictionaryValue(tags, "genre");
2013-02-21 01:33:05 +00:00
if (!string.IsNullOrEmpty(val))
{
audio.Genres.Clear();
2014-03-25 21:13:55 +00:00
foreach (var genre in Split(val, true))
{
2013-09-05 22:59:07 +00:00
audio.AddGenre(genre);
}
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>
2013-09-08 16:49:05 +00:00
/// <param name="tagName">Name of the tag.</param>
2013-02-21 01:33:05 +00:00
/// <returns>System.Nullable{System.Int32}.</returns>
2013-09-08 16:49:05 +00:00
private int? GetDictionaryDiscValue(Dictionary<string, string> tags, string tagName)
2013-02-21 01:33:05 +00:00
{
var disc = FFProbeHelpers.GetDictionaryValue(tags, tagName);
2013-02-21 01:33:05 +00:00
if (!string.IsNullOrEmpty(disc))
{
disc = disc.Split('/')[0];
int num;
if (int.TryParse(disc, out num))
{
return num;
}
}
return null;
}
}
2013-02-21 01:33:05 +00:00
}