/// <summary>
/// Resolves the video.
/// </summary>
/// <typeparam name="TVideoType">The type of the T video type.</typeparam>
/// <param name="args">The args.</param>
/// <param name="parseName">if set to <c>true</c> [parse name].</param>
/// <returns>``0.</returns>
protected TVideoType ResolveVideo <TVideoType>(ItemResolveArgs args, bool parseName)
where TVideoType : Video, new()
{
var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
// If the path is a file check for a matching extensions
var parser = new MediaBrowser.Naming.Video.VideoResolver(namingOptions, new NullLogger());
if (args.IsDirectory)
{
TVideoType video = null;
VideoFileInfo videoInfo = null;
// Loop through each child file/folder and see if we find a video
foreach (var child in args.FileSystemChildren)
{
var filename = child.Name;
if (child.IsDirectory)
{
if (IsDvdDirectory(child.FullName, filename, args.DirectoryService))
{
videoInfo = parser.ResolveDirectory(args.Path);
if (videoInfo == null)
{
return(null);
}
video = new TVideoType
{
Path = args.Path,
VideoType = VideoType.Dvd,
ProductionYear = videoInfo.Year
};
break;
}
if (IsBluRayDirectory(child.FullName, filename, args.DirectoryService))
{
videoInfo = parser.ResolveDirectory(args.Path);
if (videoInfo == null)
{
return(null);
}
video = new TVideoType
{
Path = args.Path,
VideoType = VideoType.BluRay,
ProductionYear = videoInfo.Year
};
break;
}
}
else if (IsDvdFile(filename))
{
videoInfo = parser.ResolveDirectory(args.Path);
if (videoInfo == null)
{
return(null);
}
video = new TVideoType
{
Path = args.Path,
VideoType = VideoType.Dvd,
ProductionYear = videoInfo.Year
};
break;
}
}
if (video != null)
{
video.Name = parseName ?
videoInfo.Name :
Path.GetFileName(args.Path);
Set3DFormat(video, videoInfo);
}
return(video);
}
else
{
var videoInfo = parser.Resolve(args.Path, false, false);
if (videoInfo == null)
{
return(null);
}
if (LibraryManager.IsVideoFile(args.Path, args.GetLibraryOptions()) || videoInfo.IsStub)
{
var path = args.Path;
var video = new TVideoType
{
Path = path,
IsInMixedFolder = true,
ProductionYear = videoInfo.Year
};
SetVideoType(video, videoInfo);
video.Name = parseName ?
videoInfo.Name :
Path.GetFileNameWithoutExtension(args.Path);
Set3DFormat(video, videoInfo);
return(video);
}
}
return(null);
}
public StackResult Resolve(IEnumerable<FileMetadata> files)
{
var result = new StackResult();
var resolver = new VideoResolver(_options, _logger);
var list = files
.Where(i => i.IsFolder || (resolver.IsVideoFile(i.Id) || resolver.IsStubFile(i.Id)))
.OrderBy(i => i.Id)
.ToList();
var expressions = _options.VideoFileStackingExpressions;
for (var i = 0; i < list.Count; i++)
{
var offset = 0;
var file1 = list[i];
var expressionIndex = 0;
while (expressionIndex < expressions.Count)
{
var exp = expressions[expressionIndex];
var stack = new FileStack
{
Expression = exp
};
// (Title)(Volume)(Ignore)(Extension)
var match1 = FindMatch(file1, exp, offset);
if (match1.Success)
{
var title1 = match1.Groups[1].Value;
var volume1 = match1.Groups[2].Value;
var ignore1 = match1.Groups[3].Value;
var extension1 = match1.Groups[4].Value;
var j = i + 1;
while (j < list.Count)
{
var file2 = list[j];
if (file1.IsFolder != file2.IsFolder)
{
j++;
continue;
}
// (Title)(Volume)(Ignore)(Extension)
var match2 = FindMatch(file2, exp, offset);
if (match2.Success)
{
var title2 = match2.Groups[1].Value;
var volume2 = match2.Groups[2].Value;
var ignore2 = match2.Groups[3].Value;
var extension2 = match2.Groups[4].Value;
if (string.Equals(title1, title2, StringComparison.OrdinalIgnoreCase))
{
if (!string.Equals(volume1, volume2, StringComparison.OrdinalIgnoreCase))
{
if (string.Equals(ignore1, ignore2, StringComparison.OrdinalIgnoreCase) &&
string.Equals(extension1, extension2, StringComparison.OrdinalIgnoreCase))
{
if (stack.Files.Count == 0)
{
stack.Name = title1 + ignore1;
stack.IsFolderStack = file1.IsFolder;
//stack.Name = title1 + ignore1 + extension1;
stack.Files.Add(file1.Id);
}
stack.Files.Add(file2.Id);
}
else
{
// Sequel
offset = 0;
expressionIndex++;
break;
}
}
else if (!string.Equals(ignore1, ignore2, StringComparison.OrdinalIgnoreCase))
{
// False positive, try again with offset
offset = match1.Groups[3].Index;
break;
}
else
{
// Extension mismatch
offset = 0;
expressionIndex++;
break;
}
}
else
{
// Title mismatch
offset = 0;
expressionIndex++;
break;
}
}
else
{
// No match 2, next expression
offset = 0;
expressionIndex++;
break;
}
j++;
}
if (j == list.Count)
{
expressionIndex = expressions.Count;
}
}
else
{
// No match 1
offset = 0;
expressionIndex++;
}
if (stack.Files.Count > 1)
{
result.Stacks.Add(stack);
i += stack.Files.Count - 1;
break;
}
}
}
return result;
}
public StackResult Resolve(IEnumerable <PortableFileInfo> files)
{
var result = new StackResult();
var resolver = new VideoResolver(_options, _logger);
var list = files
.Where(i => i.Type == FileInfoType.Directory || (resolver.IsVideoFile(i.FullName) || resolver.IsStubFile(i.FullName)))
.OrderBy(i => i.FullName)
.ToList();
var expressions = _options.VideoFileStackingExpressions;
for (var i = 0; i < list.Count; i++)
{
var extraFiles = new List <string>();
var offset = 0;
var file1 = list[i];
var expressionIndex = 0;
while (expressionIndex < expressions.Count)
{
var exp = expressions[expressionIndex];
var stack = new FileStack
{
Expression = exp
};
// (Title)(Volume)(Ignore)(Extension)
var match1 = FindMatch(file1, exp, offset);
if (match1.Success)
{
var title1 = match1.Groups[1].Value;
var volume1 = match1.Groups[2].Value;
var ignore1 = match1.Groups[3].Value;
var extension1 = match1.Groups[4].Value;
var j = i + 1;
while (j < list.Count)
{
var file2 = list[j];
// (Title)(Volume)(Ignore)(Extension)
var match2 = FindMatch(file2, exp, offset);
if (match2.Success)
{
var title2 = match2.Groups[1].Value;
var volume2 = match2.Groups[2].Value;
var ignore2 = match2.Groups[3].Value;
var extension2 = match2.Groups[4].Value;
if (string.Equals(title1, title2, StringComparison.OrdinalIgnoreCase))
{
if (!string.Equals(volume1, volume2, StringComparison.OrdinalIgnoreCase))
{
if (string.Equals(ignore1, ignore2, StringComparison.OrdinalIgnoreCase) &&
string.Equals(extension1, extension2, StringComparison.OrdinalIgnoreCase))
{
if (stack.Files.Count == 0)
{
stack.Name = title1 + ignore1;
//stack.Name = title1 + ignore1 + extension1;
stack.Files.Add(file1.FullName);
}
stack.Files.Add(file2.FullName);
}
else
{
// Sequel
offset = 0;
expressionIndex++;
break;
}
}
else if (!string.Equals(ignore1, ignore2, StringComparison.OrdinalIgnoreCase))
{
// False positive, try again with offset
offset = match1.Groups[3].Index;
break;
}
else
{
// Extension mismatch
offset = 0;
expressionIndex++;
break;
}
}
else
{
// Title mismatch
offset = 0;
expressionIndex++;
break;
}
}
else
{
// No match 2, next expression
offset = 0;
expressionIndex++;
break;
}
j++;
}
if (j == list.Count)
{
expressionIndex = expressions.Count;
}
}
else
{
// No match 1
offset = 0;
expressionIndex++;
}
if (stack.Files.Count > 1)
{
result.Stacks.Add(stack);
i += stack.Files.Count - 1;
break;
}
}
}
return(result);
}
public IEnumerable<VideoInfo> Resolve(List<FileMetadata> files, bool supportMultiVersion = true)
{
var videoResolver = new VideoResolver(_options, _logger, _regexProvider);
var videoInfos = files
.Select(i => videoResolver.Resolve(i.Id, i.IsFolder))
.Where(i => i != null)
.ToList();
// Filter out all extras, otherwise they could cause stacks to not be resolved
// See the unit test TestStackedWithTrailer
var nonExtras = videoInfos
.Where(i => string.IsNullOrWhiteSpace(i.ExtraType))
.Select(i => new FileMetadata
{
Id = i.Path,
IsFolder = i.IsFolder
});
var stackResult = new StackResolver(_options, _logger, _regexProvider)
.Resolve(nonExtras);
var remainingFiles = videoInfos
.Where(i => !stackResult.Stacks.Any(s => s.ContainsFile(i.Path, i.IsFolder)))
.ToList();
var list = new List<VideoInfo>();
foreach (var stack in stackResult.Stacks)
{
var info = new VideoInfo
{
Files = stack.Files.Select(i => videoResolver.Resolve(i, stack.IsFolderStack)).ToList(),
Name = stack.Name
};
info.Year = info.Files.First().Year;
var extraBaseNames = new List<string>
{
stack.Name,
Path.GetFileNameWithoutExtension(stack.Files[0])
};
var extras = GetExtras(remainingFiles, extraBaseNames);
if (extras.Count > 0)
{
remainingFiles = remainingFiles
.Except(extras)
.ToList();
info.Extras = extras;
}
list.Add(info);
}
var standaloneMedia = remainingFiles
.Where(i => string.IsNullOrWhiteSpace(i.ExtraType))
.ToList();
foreach (var media in standaloneMedia)
{
var info = new VideoInfo
{
Files = new List<VideoFileInfo> { media },
Name = media.Name
};
info.Year = info.Files.First().Year;
var extras = GetExtras(remainingFiles, new List<string> { media.FileNameWithoutExtension, media.Name });
remainingFiles = remainingFiles
.Except(extras.Concat(new[] { media }))
.ToList();
info.Extras = extras;
list.Add(info);
}
if (supportMultiVersion)
{
list = GetVideosGroupedByVersion(list)
.ToList();
}
// If there's only one resolved video, use the folder name as well to find extras
if (list.Count == 1)
{
var info = list[0];
var videoPath = list[0].Files[0].Path;
var parentPath = Path.GetDirectoryName(videoPath);
if (!string.IsNullOrWhiteSpace(parentPath))
{
var folderName = Path.GetFileName(Path.GetDirectoryName(videoPath));
if (!string.IsNullOrWhiteSpace(folderName))
{
var extras = GetExtras(remainingFiles, new List<string> { folderName });
remainingFiles = remainingFiles
.Except(extras)
.ToList();
info.Extras.AddRange(extras);
}
}
// Add the extras that are just based on file name as well
var extrasByFileName = remainingFiles
.Where(i => i.ExtraRule != null && i.ExtraRule.RuleType == ExtraRuleType.Filename)
.ToList();
remainingFiles = remainingFiles
.Except(extrasByFileName)
.ToList();
info.Extras.AddRange(extrasByFileName);
}
// If there's only one video, accept all trailers
// Be lenient because people use all kinds of mish mash conventions with trailers
if (list.Count == 1)
{
var trailers = remainingFiles
.Where(i => string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase))
.ToList();
list[0].Extras.AddRange(trailers);
remainingFiles = remainingFiles
.Except(trailers)
.ToList();
}
// Whatever files are left, just add them
list.AddRange(remainingFiles.Select(i => new VideoInfo
{
Files = new List<VideoFileInfo> { i },
Name = i.Name,
Year = i.Year
}));
var orderedList = list.OrderBy(i => i.Name);
return orderedList;
}
public IEnumerable <VideoInfo> Resolve(List <FileMetadata> files, bool supportMultiVersion = true)
{
var videoResolver = new VideoResolver(_options, _logger, _regexProvider);
var videoInfos = files
.Select(i => videoResolver.Resolve(i.Id, i.IsFolder))
.Where(i => i != null)
.ToList();
// Filter out all extras, otherwise they could cause stacks to not be resolved
// See the unit test TestStackedWithTrailer
var nonExtras = videoInfos
.Where(i => string.IsNullOrWhiteSpace(i.ExtraType))
.Select(i => new FileMetadata
{
Id = i.Path,
IsFolder = i.IsFolder
});
var stackResult = new StackResolver(_options, _logger, _regexProvider)
.Resolve(nonExtras);
var remainingFiles = videoInfos
.Where(i => !stackResult.Stacks.Any(s => s.ContainsFile(i.Path, i.IsFolder)))
.ToList();
var list = new List <VideoInfo>();
foreach (var stack in stackResult.Stacks)
{
var info = new VideoInfo
{
Files = stack.Files.Select(i => videoResolver.Resolve(i, stack.IsFolderStack)).ToList(),
Name = stack.Name
};
info.Year = info.Files.First().Year;
var extraBaseNames = new List <string>
{
stack.Name,
Path.GetFileNameWithoutExtension(stack.Files[0])
};
var extras = GetExtras(remainingFiles, extraBaseNames);
if (extras.Count > 0)
{
remainingFiles = remainingFiles
.Except(extras)
.ToList();
info.Extras = extras;
}
list.Add(info);
}
var standaloneMedia = remainingFiles
.Where(i => string.IsNullOrWhiteSpace(i.ExtraType))
.ToList();
foreach (var media in standaloneMedia)
{
var info = new VideoInfo
{
Files = new List <VideoFileInfo> {
media
},
Name = media.Name
};
info.Year = info.Files.First().Year;
var extras = GetExtras(remainingFiles, new List <string> {
media.FileNameWithoutExtension, media.Name
});
remainingFiles = remainingFiles
.Except(extras.Concat(new[] { media }))
.ToList();
info.Extras = extras;
list.Add(info);
}
if (supportMultiVersion)
{
list = GetVideosGroupedByVersion(list)
.ToList();
}
// If there's only one resolved video, use the folder name as well to find extras
if (list.Count == 1)
{
var info = list[0];
var videoPath = list[0].Files[0].Path;
var parentPath = Path.GetDirectoryName(videoPath);
if (!string.IsNullOrWhiteSpace(parentPath))
{
var folderName = Path.GetFileName(Path.GetDirectoryName(videoPath));
if (!string.IsNullOrWhiteSpace(folderName))
{
var extras = GetExtras(remainingFiles, new List <string> {
folderName
});
remainingFiles = remainingFiles
.Except(extras)
.ToList();
info.Extras.AddRange(extras);
}
}
// Add the extras that are just based on file name as well
var extrasByFileName = remainingFiles
.Where(i => i.ExtraRule != null && i.ExtraRule.RuleType == ExtraRuleType.Filename)
.ToList();
remainingFiles = remainingFiles
.Except(extrasByFileName)
.ToList();
info.Extras.AddRange(extrasByFileName);
}
// If there's only one video, accept all trailers
// Be lenient because people use all kinds of mish mash conventions with trailers
if (list.Count == 1)
{
var trailers = remainingFiles
.Where(i => string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase))
.ToList();
list[0].Extras.AddRange(trailers);
remainingFiles = remainingFiles
.Except(trailers)
.ToList();
}
// Whatever files are left, just add them
list.AddRange(remainingFiles.Select(i => new VideoInfo
{
Files = new List <VideoFileInfo> {
i
},
Name = i.Name,
Year = i.Year
}));
var orderedList = list.OrderBy(i => i.Name);
return(orderedList);
}
