ProbeResultNormalizer.cs 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975
  1. using MediaBrowser.Common.IO;
  2. using MediaBrowser.Model.Dto;
  3. using MediaBrowser.Model.Entities;
  4. using MediaBrowser.Model.Extensions;
  5. using System;
  6. using System.Collections.Generic;
  7. using System.Globalization;
  8. using System.IO;
  9. using System.Linq;
  10. using CommonIO;
  11. using MediaBrowser.Model.Logging;
  12. using MediaBrowser.Model.MediaInfo;
  13. namespace MediaBrowser.MediaEncoding.Probing
  14. {
  15. public class ProbeResultNormalizer
  16. {
  17. private readonly CultureInfo _usCulture = new CultureInfo("en-US");
  18. private readonly ILogger _logger;
  19. private readonly IFileSystem _fileSystem;
  20. public ProbeResultNormalizer(ILogger logger, IFileSystem fileSystem)
  21. {
  22. _logger = logger;
  23. _fileSystem = fileSystem;
  24. }
  25. public MediaInfo GetMediaInfo(InternalMediaInfoResult data, VideoType videoType, bool isAudio, string path, MediaProtocol protocol)
  26. {
  27. var info = new MediaInfo
  28. {
  29. Path = path,
  30. Protocol = protocol
  31. };
  32. FFProbeHelpers.NormalizeFFProbeResult(data);
  33. SetSize(data, info);
  34. var internalStreams = data.streams ?? new MediaStreamInfo[] { };
  35. info.MediaStreams = internalStreams.Select(s => GetMediaStream(isAudio, s, data.format))
  36. .Where(i => i != null)
  37. .ToList();
  38. if (data.format != null)
  39. {
  40. info.Container = data.format.format_name;
  41. if (!string.IsNullOrEmpty(data.format.bit_rate))
  42. {
  43. int value;
  44. if (int.TryParse(data.format.bit_rate, NumberStyles.Any, _usCulture, out value))
  45. {
  46. info.Bitrate = value;
  47. }
  48. }
  49. }
  50. var tags = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
  51. var tagStreamType = isAudio ? "audio" : "video";
  52. if (data.streams != null)
  53. {
  54. var tagStream = data.streams.FirstOrDefault(i => string.Equals(i.codec_type, tagStreamType, StringComparison.OrdinalIgnoreCase));
  55. if (tagStream != null && tagStream.tags != null)
  56. {
  57. foreach (var pair in tagStream.tags)
  58. {
  59. tags[pair.Key] = pair.Value;
  60. }
  61. }
  62. }
  63. if (data.format != null && data.format.tags != null)
  64. {
  65. foreach (var pair in data.format.tags)
  66. {
  67. tags[pair.Key] = pair.Value;
  68. }
  69. }
  70. FetchGenres(info, tags);
  71. var overview = FFProbeHelpers.GetDictionaryValue(tags, "description");
  72. if (!string.IsNullOrWhiteSpace(overview))
  73. {
  74. info.Overview = overview;
  75. }
  76. var title = FFProbeHelpers.GetDictionaryValue(tags, "title");
  77. if (!string.IsNullOrWhiteSpace(title))
  78. {
  79. info.Name = title;
  80. }
  81. info.ProductionYear = FFProbeHelpers.GetDictionaryNumericValue(tags, "date");
  82. // Several different forms of retaildate
  83. info.PremiereDate = FFProbeHelpers.GetDictionaryDateTime(tags, "retaildate") ??
  84. FFProbeHelpers.GetDictionaryDateTime(tags, "retail date") ??
  85. FFProbeHelpers.GetDictionaryDateTime(tags, "retail_date") ??
  86. FFProbeHelpers.GetDictionaryDateTime(tags, "date");
  87. if (isAudio)
  88. {
  89. SetAudioRuntimeTicks(data, info);
  90. // tags are normally located under data.format, but we've seen some cases with ogg where they're part of the audio stream
  91. // so let's create a combined list of both
  92. SetAudioInfoFromTags(info, tags);
  93. }
  94. else
  95. {
  96. var iTunEXTC = FFProbeHelpers.GetDictionaryValue(tags, "iTunEXTC");
  97. if (!string.IsNullOrWhiteSpace(iTunEXTC))
  98. {
  99. var parts = iTunEXTC.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
  100. // Example
  101. // mpaa|G|100|For crude humor
  102. if (parts.Length == 4)
  103. {
  104. info.OfficialRating = parts[1];
  105. info.OfficialRatingDescription = parts[3];
  106. }
  107. }
  108. var itunesXml = FFProbeHelpers.GetDictionaryValue(tags, "iTunMOVI");
  109. if (!string.IsNullOrWhiteSpace(itunesXml))
  110. {
  111. FetchFromItunesInfo(itunesXml, info);
  112. }
  113. if (data.format != null && !string.IsNullOrEmpty(data.format.duration))
  114. {
  115. info.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(data.format.duration, _usCulture)).Ticks;
  116. }
  117. FetchWtvInfo(info, data);
  118. if (data.Chapters != null)
  119. {
  120. info.Chapters = data.Chapters.Select(GetChapterInfo).ToList();
  121. }
  122. ExtractTimestamp(info);
  123. }
  124. return info;
  125. }
  126. private void FetchFromItunesInfo(string xml, MediaInfo info)
  127. {
  128. // <?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n<plist version=\"1.0\">\n<dict>\n\t<key>cast</key>\n\t<array>\n\t\t<dict>\n\t\t\t<key>name</key>\n\t\t\t<string>Blender Foundation</string>\n\t\t</dict>\n\t\t<dict>\n\t\t\t<key>name</key>\n\t\t\t<string>Janus Bager Kristensen</string>\n\t\t</dict>\n\t</array>\n\t<key>directors</key>\n\t<array>\n\t\t<dict>\n\t\t\t<key>name</key>\n\t\t\t<string>Sacha Goedegebure</string>\n\t\t</dict>\n\t</array>\n\t<key>studio</key>\n\t<string>Blender Foundation</string>\n</dict>\n</plist>\n
  129. }
  130. /// <summary>
  131. /// Converts ffprobe stream info to our MediaStream class
  132. /// </summary>
  133. /// <param name="isAudio">if set to <c>true</c> [is audio].</param>
  134. /// <param name="streamInfo">The stream info.</param>
  135. /// <param name="formatInfo">The format info.</param>
  136. /// <returns>MediaStream.</returns>
  137. private MediaStream GetMediaStream(bool isAudio, MediaStreamInfo streamInfo, MediaFormatInfo formatInfo)
  138. {
  139. // These are mp4 chapters
  140. if (string.Equals(streamInfo.codec_name, "mov_text", StringComparison.OrdinalIgnoreCase))
  141. {
  142. return null;
  143. }
  144. var stream = new MediaStream
  145. {
  146. Codec = streamInfo.codec_name,
  147. Profile = streamInfo.profile,
  148. Level = streamInfo.level,
  149. Index = streamInfo.index,
  150. PixelFormat = streamInfo.pix_fmt
  151. };
  152. // Filter out junk
  153. if (!string.IsNullOrWhiteSpace(streamInfo.codec_tag_string) && streamInfo.codec_tag_string.IndexOf("[0]", StringComparison.OrdinalIgnoreCase) == -1)
  154. {
  155. stream.CodecTag = streamInfo.codec_tag_string;
  156. }
  157. if (streamInfo.tags != null)
  158. {
  159. stream.Language = GetDictionaryValue(streamInfo.tags, "language");
  160. stream.Comment = GetDictionaryValue(streamInfo.tags, "comment");
  161. }
  162. if (string.Equals(streamInfo.codec_type, "audio", StringComparison.OrdinalIgnoreCase))
  163. {
  164. stream.Type = MediaStreamType.Audio;
  165. stream.Channels = streamInfo.channels;
  166. if (!string.IsNullOrEmpty(streamInfo.sample_rate))
  167. {
  168. int value;
  169. if (int.TryParse(streamInfo.sample_rate, NumberStyles.Any, _usCulture, out value))
  170. {
  171. stream.SampleRate = value;
  172. }
  173. }
  174. stream.ChannelLayout = ParseChannelLayout(streamInfo.channel_layout);
  175. if (streamInfo.bits_per_sample > 0)
  176. {
  177. stream.BitDepth = streamInfo.bits_per_sample;
  178. }
  179. else if (streamInfo.bits_per_raw_sample > 0)
  180. {
  181. stream.BitDepth = streamInfo.bits_per_raw_sample;
  182. }
  183. }
  184. else if (string.Equals(streamInfo.codec_type, "subtitle", StringComparison.OrdinalIgnoreCase))
  185. {
  186. stream.Type = MediaStreamType.Subtitle;
  187. }
  188. else if (string.Equals(streamInfo.codec_type, "video", StringComparison.OrdinalIgnoreCase))
  189. {
  190. stream.Type = isAudio || string.Equals(stream.Codec, "mjpeg", StringComparison.OrdinalIgnoreCase) || string.Equals(stream.Codec, "gif", StringComparison.OrdinalIgnoreCase)
  191. ? MediaStreamType.EmbeddedImage
  192. : MediaStreamType.Video;
  193. stream.Width = streamInfo.width;
  194. stream.Height = streamInfo.height;
  195. stream.AspectRatio = GetAspectRatio(streamInfo);
  196. stream.AverageFrameRate = GetFrameRate(streamInfo.avg_frame_rate);
  197. stream.RealFrameRate = GetFrameRate(streamInfo.r_frame_rate);
  198. if (streamInfo.bits_per_sample > 0)
  199. {
  200. stream.BitDepth = streamInfo.bits_per_sample;
  201. }
  202. else if (streamInfo.bits_per_raw_sample > 0)
  203. {
  204. stream.BitDepth = streamInfo.bits_per_raw_sample;
  205. }
  206. //stream.IsAnamorphic = string.Equals(streamInfo.sample_aspect_ratio, "0:1", StringComparison.OrdinalIgnoreCase) ||
  207. // string.Equals(stream.AspectRatio, "2.35:1", StringComparison.OrdinalIgnoreCase) ||
  208. // string.Equals(stream.AspectRatio, "2.40:1", StringComparison.OrdinalIgnoreCase);
  209. // http://stackoverflow.com/questions/17353387/how-to-detect-anamorphic-video-with-ffprobe
  210. stream.IsAnamorphic = string.Equals(streamInfo.sample_aspect_ratio, "0:1", StringComparison.OrdinalIgnoreCase);
  211. if (streamInfo.refs > 0)
  212. {
  213. stream.RefFrames = streamInfo.refs;
  214. }
  215. }
  216. else
  217. {
  218. return null;
  219. }
  220. // Get stream bitrate
  221. var bitrate = 0;
  222. if (!string.IsNullOrEmpty(streamInfo.bit_rate))
  223. {
  224. int value;
  225. if (int.TryParse(streamInfo.bit_rate, NumberStyles.Any, _usCulture, out value))
  226. {
  227. bitrate = value;
  228. }
  229. }
  230. if (bitrate == 0 && formatInfo != null && !string.IsNullOrEmpty(formatInfo.bit_rate) && stream.Type == MediaStreamType.Video)
  231. {
  232. // If the stream info doesn't have a bitrate get the value from the media format info
  233. int value;
  234. if (int.TryParse(formatInfo.bit_rate, NumberStyles.Any, _usCulture, out value))
  235. {
  236. bitrate = value;
  237. }
  238. }
  239. if (bitrate > 0)
  240. {
  241. stream.BitRate = bitrate;
  242. }
  243. if (streamInfo.disposition != null)
  244. {
  245. var isDefault = GetDictionaryValue(streamInfo.disposition, "default");
  246. var isForced = GetDictionaryValue(streamInfo.disposition, "forced");
  247. stream.IsDefault = string.Equals(isDefault, "1", StringComparison.OrdinalIgnoreCase);
  248. stream.IsForced = string.Equals(isForced, "1", StringComparison.OrdinalIgnoreCase);
  249. }
  250. return stream;
  251. }
  252. /// <summary>
  253. /// Gets a string from an FFProbeResult tags dictionary
  254. /// </summary>
  255. /// <param name="tags">The tags.</param>
  256. /// <param name="key">The key.</param>
  257. /// <returns>System.String.</returns>
  258. private string GetDictionaryValue(Dictionary<string, string> tags, string key)
  259. {
  260. if (tags == null)
  261. {
  262. return null;
  263. }
  264. string val;
  265. tags.TryGetValue(key, out val);
  266. return val;
  267. }
  268. private string ParseChannelLayout(string input)
  269. {
  270. if (string.IsNullOrEmpty(input))
  271. {
  272. return input;
  273. }
  274. return input.Split('(').FirstOrDefault();
  275. }
  276. private string GetAspectRatio(MediaStreamInfo info)
  277. {
  278. var original = info.display_aspect_ratio;
  279. int height;
  280. int width;
  281. var parts = (original ?? string.Empty).Split(':');
  282. if (!(parts.Length == 2 &&
  283. int.TryParse(parts[0], NumberStyles.Any, _usCulture, out width) &&
  284. int.TryParse(parts[1], NumberStyles.Any, _usCulture, out height) &&
  285. width > 0 &&
  286. height > 0))
  287. {
  288. width = info.width;
  289. height = info.height;
  290. }
  291. if (width > 0 && height > 0)
  292. {
  293. double ratio = width;
  294. ratio /= height;
  295. if (IsClose(ratio, 1.777777778, .03))
  296. {
  297. return "16:9";
  298. }
  299. if (IsClose(ratio, 1.3333333333, .05))
  300. {
  301. return "4:3";
  302. }
  303. if (IsClose(ratio, 1.41))
  304. {
  305. return "1.41:1";
  306. }
  307. if (IsClose(ratio, 1.5))
  308. {
  309. return "1.5:1";
  310. }
  311. if (IsClose(ratio, 1.6))
  312. {
  313. return "1.6:1";
  314. }
  315. if (IsClose(ratio, 1.66666666667))
  316. {
  317. return "5:3";
  318. }
  319. if (IsClose(ratio, 1.85, .02))
  320. {
  321. return "1.85:1";
  322. }
  323. if (IsClose(ratio, 2.35, .025))
  324. {
  325. return "2.35:1";
  326. }
  327. if (IsClose(ratio, 2.4, .025))
  328. {
  329. return "2.40:1";
  330. }
  331. }
  332. return original;
  333. }
  334. private bool IsClose(double d1, double d2, double variance = .005)
  335. {
  336. return Math.Abs(d1 - d2) <= variance;
  337. }
  338. /// <summary>
  339. /// Gets a frame rate from a string value in ffprobe output
  340. /// This could be a number or in the format of 2997/125.
  341. /// </summary>
  342. /// <param name="value">The value.</param>
  343. /// <returns>System.Nullable{System.Single}.</returns>
  344. private float? GetFrameRate(string value)
  345. {
  346. if (!string.IsNullOrEmpty(value))
  347. {
  348. var parts = value.Split('/');
  349. float result;
  350. if (parts.Length == 2)
  351. {
  352. result = float.Parse(parts[0], _usCulture) / float.Parse(parts[1], _usCulture);
  353. }
  354. else
  355. {
  356. result = float.Parse(parts[0], _usCulture);
  357. }
  358. return float.IsNaN(result) ? (float?)null : result;
  359. }
  360. return null;
  361. }
  362. private void SetAudioRuntimeTicks(InternalMediaInfoResult result, Model.MediaInfo.MediaInfo data)
  363. {
  364. if (result.streams != null)
  365. {
  366. // Get the first audio stream
  367. var stream = result.streams.FirstOrDefault(s => string.Equals(s.codec_type, "audio", StringComparison.OrdinalIgnoreCase));
  368. if (stream != null)
  369. {
  370. // Get duration from stream properties
  371. var duration = stream.duration;
  372. // If it's not there go into format properties
  373. if (string.IsNullOrEmpty(duration))
  374. {
  375. duration = result.format.duration;
  376. }
  377. // If we got something, parse it
  378. if (!string.IsNullOrEmpty(duration))
  379. {
  380. data.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(duration, _usCulture)).Ticks;
  381. }
  382. }
  383. }
  384. }
  385. private void SetSize(InternalMediaInfoResult data, Model.MediaInfo.MediaInfo info)
  386. {
  387. if (data.format != null)
  388. {
  389. if (!string.IsNullOrEmpty(data.format.size))
  390. {
  391. info.Size = long.Parse(data.format.size, _usCulture);
  392. }
  393. else
  394. {
  395. info.Size = null;
  396. }
  397. }
  398. }
  399. private void SetAudioInfoFromTags(MediaInfo audio, Dictionary<string, string> tags)
  400. {
  401. var composer = FFProbeHelpers.GetDictionaryValue(tags, "composer");
  402. if (!string.IsNullOrWhiteSpace(composer))
  403. {
  404. foreach (var person in Split(composer, false))
  405. {
  406. audio.People.Add(new BaseItemPerson { Name = person, Type = PersonType.Composer });
  407. }
  408. }
  409. var conductor = FFProbeHelpers.GetDictionaryValue(tags, "conductor");
  410. if (!string.IsNullOrWhiteSpace(conductor))
  411. {
  412. foreach (var person in Split(conductor, false))
  413. {
  414. audio.People.Add(new BaseItemPerson { Name = person, Type = PersonType.Conductor });
  415. }
  416. }
  417. var lyricist = FFProbeHelpers.GetDictionaryValue(tags, "lyricist");
  418. if (!string.IsNullOrWhiteSpace(lyricist))
  419. {
  420. foreach (var person in Split(lyricist, false))
  421. {
  422. audio.People.Add(new BaseItemPerson { Name = person, Type = PersonType.Lyricist });
  423. }
  424. }
  425. // Check for writer some music is tagged that way as alternative to composer/lyricist
  426. var writer = FFProbeHelpers.GetDictionaryValue(tags, "writer");
  427. if (!string.IsNullOrWhiteSpace(writer))
  428. {
  429. foreach (var person in Split(writer, false))
  430. {
  431. audio.People.Add(new BaseItemPerson { Name = person, Type = PersonType.Writer });
  432. }
  433. }
  434. audio.Album = FFProbeHelpers.GetDictionaryValue(tags, "album");
  435. var artists = FFProbeHelpers.GetDictionaryValue(tags, "artists");
  436. if (!string.IsNullOrWhiteSpace(artists))
  437. {
  438. audio.Artists = SplitArtists(artists, new[] { '/', ';' }, false)
  439. .Distinct(StringComparer.OrdinalIgnoreCase)
  440. .ToList();
  441. }
  442. else
  443. {
  444. var artist = FFProbeHelpers.GetDictionaryValue(tags, "artist");
  445. if (string.IsNullOrWhiteSpace(artist))
  446. {
  447. audio.Artists.Clear();
  448. }
  449. else
  450. {
  451. audio.Artists = SplitArtists(artist, _nameDelimiters, true)
  452. .Distinct(StringComparer.OrdinalIgnoreCase)
  453. .ToList();
  454. }
  455. }
  456. var albumArtist = FFProbeHelpers.GetDictionaryValue(tags, "albumartist");
  457. if (string.IsNullOrWhiteSpace(albumArtist))
  458. {
  459. albumArtist = FFProbeHelpers.GetDictionaryValue(tags, "album artist");
  460. }
  461. if (string.IsNullOrWhiteSpace(albumArtist))
  462. {
  463. albumArtist = FFProbeHelpers.GetDictionaryValue(tags, "album_artist");
  464. }
  465. if (string.IsNullOrWhiteSpace(albumArtist))
  466. {
  467. audio.AlbumArtists = new List<string>();
  468. }
  469. else
  470. {
  471. audio.AlbumArtists = SplitArtists(albumArtist, _nameDelimiters, true)
  472. .Distinct(StringComparer.OrdinalIgnoreCase)
  473. .ToList();
  474. }
  475. // Track number
  476. audio.IndexNumber = GetDictionaryDiscValue(tags, "track");
  477. // Disc number
  478. audio.ParentIndexNumber = GetDictionaryDiscValue(tags, "disc");
  479. // If we don't have a ProductionYear try and get it from PremiereDate
  480. if (audio.PremiereDate.HasValue && !audio.ProductionYear.HasValue)
  481. {
  482. audio.ProductionYear = audio.PremiereDate.Value.ToLocalTime().Year;
  483. }
  484. // There's several values in tags may or may not be present
  485. FetchStudios(audio, tags, "organization");
  486. FetchStudios(audio, tags, "ensemble");
  487. FetchStudios(audio, tags, "publisher");
  488. FetchStudios(audio, tags, "label");
  489. // These support mulitple values, but for now we only store the first.
  490. var mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Album Artist Id"));
  491. if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_ALBUMARTISTID"));
  492. audio.SetProviderId(MetadataProviders.MusicBrainzAlbumArtist, mb);
  493. mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Artist Id"));
  494. if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_ARTISTID"));
  495. audio.SetProviderId(MetadataProviders.MusicBrainzArtist, mb);
  496. mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Album Id"));
  497. if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_ALBUMID"));
  498. audio.SetProviderId(MetadataProviders.MusicBrainzAlbum, mb);
  499. mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Release Group Id"));
  500. if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_RELEASEGROUPID"));
  501. audio.SetProviderId(MetadataProviders.MusicBrainzReleaseGroup, mb);
  502. mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MusicBrainz Release Track Id"));
  503. if (mb == null) mb = GetMultipleMusicBrainzId(FFProbeHelpers.GetDictionaryValue(tags, "MUSICBRAINZ_RELEASETRACKID"));
  504. audio.SetProviderId(MetadataProviders.MusicBrainzTrack, mb);
  505. }
  506. private string GetMultipleMusicBrainzId(string value)
  507. {
  508. if (string.IsNullOrWhiteSpace(value))
  509. {
  510. return null;
  511. }
  512. return value.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)
  513. .Select(i => i.Trim())
  514. .FirstOrDefault(i => !string.IsNullOrWhiteSpace(i));
  515. }
  516. private readonly char[] _nameDelimiters = { '/', '|', ';', '\\' };
  517. /// <summary>
  518. /// Splits the specified val.
  519. /// </summary>
  520. /// <param name="val">The val.</param>
  521. /// <param name="allowCommaDelimiter">if set to <c>true</c> [allow comma delimiter].</param>
  522. /// <returns>System.String[][].</returns>
  523. private IEnumerable<string> Split(string val, bool allowCommaDelimiter)
  524. {
  525. // Only use the comma as a delimeter if there are no slashes or pipes.
  526. // We want to be careful not to split names that have commas in them
  527. var delimeter = !allowCommaDelimiter || _nameDelimiters.Any(i => val.IndexOf(i) != -1) ?
  528. _nameDelimiters :
  529. new[] { ',' };
  530. return val.Split(delimeter, StringSplitOptions.RemoveEmptyEntries)
  531. .Where(i => !string.IsNullOrWhiteSpace(i))
  532. .Select(i => i.Trim());
  533. }
  534. private const string ArtistReplaceValue = " | ";
  535. private IEnumerable<string> SplitArtists(string val, char[] delimiters, bool splitFeaturing)
  536. {
  537. if (splitFeaturing)
  538. {
  539. val = val.Replace(" featuring ", ArtistReplaceValue, StringComparison.OrdinalIgnoreCase)
  540. .Replace(" feat. ", ArtistReplaceValue, StringComparison.OrdinalIgnoreCase);
  541. }
  542. var artistsFound = new List<string>();
  543. foreach (var whitelistArtist in GetSplitWhitelist())
  544. {
  545. var originalVal = val;
  546. val = val.Replace(whitelistArtist, "|", StringComparison.OrdinalIgnoreCase);
  547. if (!string.Equals(originalVal, val, StringComparison.OrdinalIgnoreCase))
  548. {
  549. artistsFound.Add(whitelistArtist);
  550. }
  551. }
  552. var artists = val.Split(delimiters, StringSplitOptions.RemoveEmptyEntries)
  553. .Where(i => !string.IsNullOrWhiteSpace(i))
  554. .Select(i => i.Trim());
  555. artistsFound.AddRange(artists);
  556. return artistsFound;
  557. }
  558. private List<string> _splitWhiteList = null;
  559. private IEnumerable<string> GetSplitWhitelist()
  560. {
  561. if (_splitWhiteList == null)
  562. {
  563. var file = GetType().Namespace + ".whitelist.txt";
  564. using (var stream = GetType().Assembly.GetManifestResourceStream(file))
  565. {
  566. using (var reader = new StreamReader(stream))
  567. {
  568. var list = new List<string>();
  569. while (!reader.EndOfStream)
  570. {
  571. var val = reader.ReadLine();
  572. if (!string.IsNullOrWhiteSpace(val))
  573. {
  574. list.Add(val);
  575. }
  576. }
  577. _splitWhiteList = list;
  578. }
  579. }
  580. }
  581. return _splitWhiteList;
  582. }
  583. /// <summary>
  584. /// Gets the studios from the tags collection
  585. /// </summary>
  586. /// <param name="audio">The audio.</param>
  587. /// <param name="tags">The tags.</param>
  588. /// <param name="tagName">Name of the tag.</param>
  589. private void FetchStudios(Model.MediaInfo.MediaInfo audio, Dictionary<string, string> tags, string tagName)
  590. {
  591. var val = FFProbeHelpers.GetDictionaryValue(tags, tagName);
  592. if (!string.IsNullOrEmpty(val))
  593. {
  594. var studios = Split(val, true);
  595. foreach (var studio in studios)
  596. {
  597. // Sometimes the artist name is listed here, account for that
  598. if (audio.Artists.Contains(studio, StringComparer.OrdinalIgnoreCase))
  599. {
  600. continue;
  601. }
  602. if (audio.AlbumArtists.Contains(studio, StringComparer.OrdinalIgnoreCase))
  603. {
  604. continue;
  605. }
  606. audio.Studios.Add(studio);
  607. }
  608. audio.Studios = audio.Studios
  609. .Where(i => !string.IsNullOrWhiteSpace(i))
  610. .Distinct(StringComparer.OrdinalIgnoreCase)
  611. .ToList();
  612. }
  613. }
  614. /// <summary>
  615. /// Gets the genres from the tags collection
  616. /// </summary>
  617. /// <param name="info">The information.</param>
  618. /// <param name="tags">The tags.</param>
  619. private void FetchGenres(MediaInfo info, Dictionary<string, string> tags)
  620. {
  621. var val = FFProbeHelpers.GetDictionaryValue(tags, "genre");
  622. if (!string.IsNullOrEmpty(val))
  623. {
  624. foreach (var genre in Split(val, true))
  625. {
  626. info.Genres.Add(genre);
  627. }
  628. info.Genres = info.Genres
  629. .Where(i => !string.IsNullOrWhiteSpace(i))
  630. .Distinct(StringComparer.OrdinalIgnoreCase)
  631. .ToList();
  632. }
  633. }
  634. /// <summary>
  635. /// Gets the disc number, which is sometimes can be in the form of '1', or '1/3'
  636. /// </summary>
  637. /// <param name="tags">The tags.</param>
  638. /// <param name="tagName">Name of the tag.</param>
  639. /// <returns>System.Nullable{System.Int32}.</returns>
  640. private int? GetDictionaryDiscValue(Dictionary<string, string> tags, string tagName)
  641. {
  642. var disc = FFProbeHelpers.GetDictionaryValue(tags, tagName);
  643. if (!string.IsNullOrEmpty(disc))
  644. {
  645. disc = disc.Split('/')[0];
  646. int num;
  647. if (int.TryParse(disc, out num))
  648. {
  649. return num;
  650. }
  651. }
  652. return null;
  653. }
  654. private ChapterInfo GetChapterInfo(MediaChapter chapter)
  655. {
  656. var info = new ChapterInfo();
  657. if (chapter.tags != null)
  658. {
  659. string name;
  660. if (chapter.tags.TryGetValue("title", out name))
  661. {
  662. info.Name = name;
  663. }
  664. }
  665. // Limit accuracy to milliseconds to match xml saving
  666. var secondsString = chapter.start_time;
  667. double seconds;
  668. if (double.TryParse(secondsString, NumberStyles.Any, CultureInfo.InvariantCulture, out seconds))
  669. {
  670. var ms = Math.Round(TimeSpan.FromSeconds(seconds).TotalMilliseconds);
  671. info.StartPositionTicks = TimeSpan.FromMilliseconds(ms).Ticks;
  672. }
  673. return info;
  674. }
  675. private const int MaxSubtitleDescriptionExtractionLength = 100; // When extracting subtitles, the maximum length to consider (to avoid invalid filenames)
  676. private void FetchWtvInfo(MediaInfo video, InternalMediaInfoResult data)
  677. {
  678. if (data.format == null || data.format.tags == null)
  679. {
  680. return;
  681. }
  682. var genres = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/Genre");
  683. if (!string.IsNullOrWhiteSpace(genres))
  684. {
  685. var genreList = genres.Split(new[] { ';', '/', ',' }, StringSplitOptions.RemoveEmptyEntries)
  686. .Where(i => !string.IsNullOrWhiteSpace(i))
  687. .Select(i => i.Trim())
  688. .ToList();
  689. // If this is empty then don't overwrite genres that might have been fetched earlier
  690. if (genreList.Count > 0)
  691. {
  692. video.Genres = genreList;
  693. }
  694. }
  695. var officialRating = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/ParentalRating");
  696. if (!string.IsNullOrWhiteSpace(officialRating))
  697. {
  698. video.OfficialRating = officialRating;
  699. }
  700. var people = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/MediaCredits");
  701. if (!string.IsNullOrEmpty(people))
  702. {
  703. video.People = people.Split(new[] { ';', '/' }, StringSplitOptions.RemoveEmptyEntries)
  704. .Where(i => !string.IsNullOrWhiteSpace(i))
  705. .Select(i => new BaseItemPerson { Name = i.Trim(), Type = PersonType.Actor })
  706. .ToList();
  707. }
  708. var year = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/OriginalReleaseTime");
  709. if (!string.IsNullOrWhiteSpace(year))
  710. {
  711. int val;
  712. if (int.TryParse(year, NumberStyles.Integer, _usCulture, out val))
  713. {
  714. video.ProductionYear = val;
  715. }
  716. }
  717. var premiereDateString = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/MediaOriginalBroadcastDateTime");
  718. if (!string.IsNullOrWhiteSpace(premiereDateString))
  719. {
  720. DateTime val;
  721. // Credit to MCEBuddy: https://mcebuddy2x.codeplex.com/
  722. // DateTime is reported along with timezone info (typically Z i.e. UTC hence assume None)
  723. if (DateTime.TryParse(year, null, DateTimeStyles.None, out val))
  724. {
  725. video.PremiereDate = val.ToUniversalTime();
  726. }
  727. }
  728. var description = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/SubTitleDescription");
  729. var subTitle = FFProbeHelpers.GetDictionaryValue(data.format.tags, "WM/SubTitle");
  730. // For below code, credit to MCEBuddy: https://mcebuddy2x.codeplex.com/
  731. // Sometimes for TV Shows the Subtitle field is empty and the subtitle description contains the subtitle, extract if possible. See ticket https://mcebuddy2x.codeplex.com/workitem/1910
  732. // The format is -> EPISODE/TOTAL_EPISODES_IN_SEASON. SUBTITLE: DESCRIPTION
  733. // OR -> COMMENT. SUBTITLE: DESCRIPTION
  734. // e.g. -> 4/13. The Doctor's Wife: Science fiction drama. When he follows a Time Lord distress signal, the Doctor puts Amy, Rory and his beloved TARDIS in grave danger. Also in HD. [AD,S]
  735. // e.g. -> CBeebies Bedtime Hour. The Mystery: Animated adventures of two friends who live on an island in the middle of the big city. Some of Abney and Teal's favourite objects are missing. [S]
  736. if (String.IsNullOrWhiteSpace(subTitle) && !String.IsNullOrWhiteSpace(description) && description.Substring(0, Math.Min(description.Length, MaxSubtitleDescriptionExtractionLength)).Contains(":")) // Check within the Subtitle size limit, otherwise from description it can get too long creating an invalid filename
  737. {
  738. string[] parts = description.Split(':');
  739. if (parts.Length > 0)
  740. {
  741. string subtitle = parts[0];
  742. try
  743. {
  744. if (subtitle.Contains("/")) // It contains a episode number and season number
  745. {
  746. string[] numbers = subtitle.Split(' ');
  747. video.IndexNumber = int.Parse(numbers[0].Replace(".", "").Split('/')[0]);
  748. int totalEpisodesInSeason = int.Parse(numbers[0].Replace(".", "").Split('/')[1]);
  749. description = String.Join(" ", numbers, 1, numbers.Length - 1).Trim(); // Skip the first, concatenate the rest, clean up spaces and save it
  750. }
  751. else
  752. throw new Exception(); // Switch to default parsing
  753. }
  754. catch // Default parsing
  755. {
  756. if (subtitle.Contains(".")) // skip the comment, keep the subtitle
  757. description = String.Join(".", subtitle.Split('.'), 1, subtitle.Split('.').Length - 1).Trim(); // skip the first
  758. else
  759. description = subtitle.Trim(); // Clean up whitespaces and save it
  760. }
  761. }
  762. }
  763. if (!string.IsNullOrWhiteSpace(description))
  764. {
  765. video.Overview = description;
  766. }
  767. }
  768. private void ExtractTimestamp(MediaInfo video)
  769. {
  770. if (video.VideoType == VideoType.VideoFile)
  771. {
  772. if (string.Equals(video.Container, "mpeg2ts", StringComparison.OrdinalIgnoreCase) ||
  773. string.Equals(video.Container, "m2ts", StringComparison.OrdinalIgnoreCase) ||
  774. string.Equals(video.Container, "ts", StringComparison.OrdinalIgnoreCase))
  775. {
  776. try
  777. {
  778. video.Timestamp = GetMpegTimestamp(video.Path);
  779. _logger.Debug("Video has {0} timestamp", video.Timestamp);
  780. }
  781. catch (Exception ex)
  782. {
  783. _logger.ErrorException("Error extracting timestamp info from {0}", ex, video.Path);
  784. video.Timestamp = null;
  785. }
  786. }
  787. }
  788. }
  789. private TransportStreamTimestamp GetMpegTimestamp(string path)
  790. {
  791. var packetBuffer = new byte['Å'];
  792. using (var fs = _fileSystem.GetFileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
  793. {
  794. fs.Read(packetBuffer, 0, packetBuffer.Length);
  795. }
  796. if (packetBuffer[0] == 71)
  797. {
  798. return TransportStreamTimestamp.None;
  799. }
  800. if ((packetBuffer[4] == 71) && (packetBuffer['Ä'] == 71))
  801. {
  802. if ((packetBuffer[0] == 0) && (packetBuffer[1] == 0) && (packetBuffer[2] == 0) && (packetBuffer[3] == 0))
  803. {
  804. return TransportStreamTimestamp.Zero;
  805. }
  806. return TransportStreamTimestamp.Valid;
  807. }
  808. return TransportStreamTimestamp.None;
  809. }
  810. }
  811. }