public List <VideoInfosScanSource> ScanSource(List <string> sources, DoWorkEventArgs doWorkEvent)
{
if (sources.Count() == 0)
{
throw new ArgumentException("sources cannot be empty", "sources");
}
ParseVideo parseVideo = new ParseVideo();
// Abort the operation if the user has canceled.
// Note that a call to CancelAsync may have set
// CancellationPending to true just after the
// last invocation of this method exits, so this
// code will not have the opportunity to set the
// DoWorkEventArgs.Cancel flag to true. This means
// that RunWorkerCompletedEventArgs.Cancelled will
// not be set to true in your RunWorkerCompleted
// event handler. This is a race condition.
if (backgroundWorker.CancellationPending)
{
doWorkEvent.Cancel = true;
return(null);
}
// Data structure to hold names of subfolders to be examined for files.
Stack <DirInfo> dirNodes = new Stack <DirInfo>(1000);
List <VideoInfosScanSource> videoInfosScanSources = new List <VideoInfosScanSource>();
percentComplete = 0;
backgroundWorker.ReportProgress(percentComplete, "Processing sources..");
// get the root dirs from each source
int nbrSources = sources.Count();
int processingSource = 0;
foreach (string source in sources)
{
percentComplete = (int)Math.Floor((double)processingSource / (double)nbrSources * 100);
backgroundWorker.ReportProgress(percentComplete, "Scanning source " + source + "..");
List <VideoInfo> videoInfos = new List <VideoInfo>(10000);
string sourceAlias = Config.SourceDirectory2Alias(source);
IEnumerable <string> directories = MyFile.EnumerateDirectories(source, "*", SearchOption.AllDirectories);
int nbrDirectories = directories.Count();
int processingDirectory = 0;
foreach (string directory in directories)
{
MyLog.Add("Scanning: " + directory);
VideoInfo videoInfo = parseVideo.ReadDirectory(directory);
if (videoInfo == null || videoInfo.videoItem == null || videoInfo.videoItem.title == null ||
videoInfo.files == null || videoInfo.files.video == null)
{
processingDirectory++;
continue;
}
videoInfo.sourceAlias = sourceAlias;
videoInfo.videoDirectory = directory;
// see if any existing item or new
videoInfo.index = videoInfos.Count;
string hash = ListVideoInfo.CreateHash(videoInfo);
videoInfo.hash = hash;
VideoInfo foundVideoInfo = ListVideoInfo.FindVideoInfo("hash", hash);
bool bNew = false;
if (foundVideoInfo == null)
{
bNew = true;
}
if (bNew || foundVideoInfo.added == null || foundVideoInfo.added == DateTime.MinValue)
{
videoInfo.added = DateTime.UtcNow;
}
if (bNew || foundVideoInfo.updated == null || foundVideoInfo.updated == DateTime.MinValue)
{
videoInfo.updated = videoInfo.added;
}
if (!bNew)
{
// TODO ? needed? found item in list, merge list item with scanned item, scanned item wins
videoInfo = ListVideoInfo.MergeVideoInfos(foundVideoInfo, videoInfo);
}
videoInfos.Add(videoInfo);
processingDirectory++;
if (processingDirectory % 1 == 0)
{
percentComplete = (int)Math.Floor((double)processingDirectory / (double)nbrDirectories * 100);
string progressMessage = "Scanned " + processingDirectory + " of " + nbrDirectories + " directories\n" + directory.Split(Path.DirectorySeparatorChar).Last() + "..";
// progressMessage = directory.Split(Path.DirectorySeparatorChar).Last() + "..";
backgroundWorker.ReportProgress(percentComplete, progressMessage);
// Thread.Sleep(1000); // dev
if (backgroundWorker.CancellationPending)
{
doWorkEvent.Cancel = true;
return(null);
}
}
} // foreach directory
VideoInfosScanSource videoInfosScanSource = new VideoInfosScanSource();
videoInfosScanSource.videoInfos = videoInfos;
videoInfosScanSource.sourceAlias = sourceAlias;
videoInfosScanSources.Add(videoInfosScanSource);
processingSource++;
} // end foreach source
// add items to main list .. but not here .. in completed event
// ListVideoInfo.Clear();
// ListVideoInfo.AddItems(videoInfos);
percentComplete = 100;
backgroundWorker.ReportProgress(percentComplete, "Completed scan");
// meh, so completed msg shows
Thread.Sleep(500);
return(videoInfosScanSources);
}
/// <summary>
/// update the MB .xml file
/// </summary>
/// <param name="videoItemFile"></param>
/// <param name="videoItem"></param>
/// <returns></returns>
public bool UpdateMB(VideoInfo videoInfo)
{
string videoFullName = null;
string fileContents = null;
if (videoInfo.files == null || videoInfo.files.mb == null)
{
if (Config.settings.createMB)
{
videoFullName = videoInfo.videoDirectory + @"\movie.xml";
fileContents = GetDefaultMBxml();
}
else
{
return(false);
}
}
else if (!Config.settings.updateMB)
{
return(false);
}
else
{
videoFullName = videoInfo.GetFullName(videoInfo.files.mb);
fileContents = MyFile.ReadAllText(videoFullName);
}
if (fileContents == null || videoFullName == null)
{
return(false);
}
VideoItem videoItem = videoInfo.videoItem;
XmlDocument doc = MyXMLDoc.LoadXml(fileContents);
if (doc == null)
{
return(false);
}
MyXMLDoc.SetSingleNodeString(doc, "/Title/LocalTitle", videoItem.title);
MyXMLDoc.SetSingleNodeString(doc, "/Title/Overview", videoItem.plot);
MyXMLDoc.SetSingleNodeString(doc, "/Title/set", videoItem.movieset);
MyXMLDoc.SetSingleNodeString(doc, "/Title/tagline", videoItem.tagline);
MyXMLDoc.SetSingleNodeString(doc, "/Title/IMDB", videoItem.imdbId);
MyXMLDoc.SetSingleNodeString(doc, "/Title/TMDbId", videoItem.tmdbId);
MyXMLDoc.SetSingleNodeString(doc, "/Title/ContentRating", videoItem.mpaa);
MyXMLDoc.SetSingleNodeDecimal(doc, "/Title/Rating", videoItem.imdbRating);
MyXMLDoc.SetSingleNodeInt(doc, "/Title/ProductionYear", videoItem.year);
MyXMLDoc.SetSingleNodeInt(doc, "/Title/RunningTime", videoItem.runtime);
bool ret = MyXMLDoc.SaveXML(doc, videoFullName);
if (ret)
{
MyLog.Add("wrote " + videoFullName);
}
else
{
MyLog.Add("error writing to " + videoFullName);
}
return(ret);
}
/// <summary>
/// update the XBMC .nfo file
/// </summary>
/// <param name="videoItemFile"></param>
/// <param name="videoItem"></param>
/// <returns></returns>
public bool UpdateXBMC(VideoInfo videoInfo)
{
// MyLog.Add("UpdateXBMC");
string videoFullName = null;
string fileContents = null;
if (videoInfo.files == null || videoInfo.files.xbmc == null)
{
if (Config.settings.createXBMC)
{
videoFullName = videoInfo.videoDirectory + @"\movie.nfo";
fileContents = GetDefaultXBMCxml();
}
else
{
return(false);
}
}
else if (!Config.settings.updateXBMC)
{
return(false);
}
else
{
videoFullName = videoInfo.GetFullName(videoInfo.files.xbmc);
fileContents = MyFile.ReadAllText(videoFullName);
}
if (fileContents == null || videoFullName == null)
{
return(false);
}
VideoItem videoItem = videoInfo.videoItem;
XmlDocument doc = MyXMLDoc.LoadXml(fileContents);
if (doc == null)
{
return(false);
}
MyXMLDoc.SetSingleNodeString(doc, "/movie/title", videoItem.title);
MyXMLDoc.SetSingleNodeString(doc, "/movie/plot", videoItem.plot);
MyXMLDoc.SetSingleNodeString(doc, "/movie/set", videoItem.movieset);
MyXMLDoc.SetSingleNodeString(doc, "/movie/tagline", videoItem.tagline);
MyXMLDoc.SetSingleNodeString(doc, "/movie/id", videoItem.imdbId);
MyXMLDoc.SetSingleNodeString(doc, "/movie/tmdbId", videoItem.tmdbId);
MyXMLDoc.SetSingleNodeString(doc, "/movie/mpaa", videoItem.mpaa);
MyXMLDoc.SetSingleNodeDecimal(doc, "/movie/rating", videoItem.imdbRating);
MyXMLDoc.SetSingleNodeInt(doc, "/movie/year", videoItem.year);
MyXMLDoc.SetSingleNodeInt(doc, "/movie/runtime", videoItem.runtime);
MyXMLDoc.SetSingleNodeInt(doc, "/movie/playcount", videoItem.playCount);
int watched = VideoFileEnums.watched.GetValueByKey(videoItem.watched);
// either watched or not
if (watched != 0 && watched != 1)
{
watched = 0;
}
MyXMLDoc.SetSingleNodeInt(doc, "/movie/watched", watched);
bool ret = MyXMLDoc.SaveXML(doc, videoFullName);
if (ret)
{
MyLog.Add("wrote " + videoFullName);
}
else
{
MyLog.Add("error writing to " + videoFullName);
}
return(ret);
}
private void UserControlVideoInfo_Load(object sender, EventArgs e)
{
this.MinimumSize = new Size(350, 600);
comboBoxYear.Items.Clear();
int paddingYears = 5;
int currentYear = System.DateTime.UtcNow.Year + paddingYears;
for (int year = currentYear; year >= 1950; year--)
{
comboBoxYear.Items.Add(year);
}
comboBoxRating.Items.Clear();
for (int rating = 10; rating >= 0; rating--)
{
comboBoxRating.Items.Add(rating);
}
comboBoxIMDBRating.Items.Clear();
for (int rating = 10; rating >= 0; rating--)
{
comboBoxIMDBRating.Items.Add(rating);
}
comboBoxPlayCount.Items.Clear();
for (int playCount = 0; playCount <= 20; playCount++)
{
comboBoxPlayCount.Items.Add(playCount);
}
comboBoxSource.Items.Clear();
comboBoxSource.Items.Add("Bluray");
comboBoxSource.Items.Add("DVD");
comboBoxSource.Items.Add("Stream");
comboBoxVersion.Items.Clear();
comboBoxVersion.Items.Add("Directors");
comboBoxVersion.Items.Add("Extended");
comboBoxVersion.Items.Add("Theater");
comboBoxVersion.Items.Add("Unrated");
comboBoxCodec.Items.Clear();
comboBoxCodec.Items.Add("h264");
comboBoxSource.Items.Clear();
comboBoxSource.Items.Add("Bluray");
comboBoxSource.Items.Add("DVD");
comboBoxSource.Items.Add("Stream");
comboBoxMPAA.DropDownStyle = ComboBoxStyle.DropDown;
comboBoxMPAA.Items.Clear();
comboBoxMPAA.Items.Add("G");
comboBoxMPAA.Items.Add("PG");
comboBoxMPAA.Items.Add("PG-13");
comboBoxMPAA.Items.Add("R");
comboBoxMPAA.Items.Add("NC-17");
comboBoxMPAA.SelectedIndex = 0;
linkLabelBing.LinkBehavior = LinkBehavior.HoverUnderline;
linkLabelBing.LinkVisited = false;
linkLabelBing.LinkColor = Color.Gray;
linkLabelBing.Text = "Bing";
linkLabelGoogle.LinkBehavior = LinkBehavior.HoverUnderline;
linkLabelGoogle.LinkVisited = false;
linkLabelGoogle.LinkColor = Color.Gray;
linkLabelGoogle.Text = "Google";
linkLabelRT.LinkBehavior = LinkBehavior.HoverUnderline;
linkLabelRT.LinkVisited = false;
linkLabelRT.LinkColor = Color.Gray;
linkLabelRT.Text = "RT";
linkLabelIMDB.LinkBehavior = LinkBehavior.HoverUnderline;
linkLabelIMDB.LinkVisited = false;
linkLabelIMDB.LinkColor = Color.Gray;
linkLabelIMDB.Text = "IMDB";
linkLabelTMDB.LinkBehavior = LinkBehavior.HoverUnderline;
linkLabelTMDB.LinkVisited = false;
linkLabelTMDB.LinkColor = Color.Gray;
linkLabelTMDB.Text = "TMDB";
checkBoxWatched.Checked = false;
dataGridViewActors.Columns[1].Width = 100; // role
dataGridViewActors.Columns[0].Width = dataGridViewActors.Width - dataGridViewActors.Columns[1].Width - MyDPI.ScaleDPIDimension(5); // name
// match higlights of form fields (textboxes, comboboxes, etc) via MyFormField.HighlightFormFieldsOnFocus()
dataGridViewActors.RowTemplate.DefaultCellStyle.SelectionBackColor = Color.LightYellow;
dataGridViewActors.RowTemplate.DefaultCellStyle.SelectionForeColor = Color.Black;
dataGridViewGenres.RowTemplate.DefaultCellStyle.SelectionBackColor = Color.LightYellow;
dataGridViewGenres.RowTemplate.DefaultCellStyle.SelectionForeColor = Color.Black;
dataGridViewTags.RowTemplate.DefaultCellStyle.SelectionBackColor = Color.LightYellow;
dataGridViewTags.RowTemplate.DefaultCellStyle.SelectionForeColor = Color.Black;
VideoInfo videoInfo = new VideoInfo();
videoInfo.videoItem = new VideoItem();
SetForm(videoInfo);
DisableFormButtons();
MyTooltip tooltip = new MyTooltip();
//tooltip.SetToolTip((LinkLabel)sender, "test test");
}
public void SetForm(VideoInfo videoInfo)
{
this.selectedVideoInfo = videoInfo;
VideoItem videoItem = videoInfo.videoItem;
try
{
// set search title
MyFormField.SetTextBoxText(textBoxTitle, videoItem.title);
// set movie set
MyFormField.SetTextBoxText(textBoxMovieSet, videoItem.movieset);
// set plot
MyFormField.SetRichTextBoxText(richTextBoxPlot, videoItem.plot);
// set runtime
MyFormField.SetTextBoxText(textBoxRunTime, videoItem.runtime.ToString());
// set tagline
// MyFormField.SetTextBoxText(textBoxTagLine, videoItem.tagline); // not yet
// set notes
MyFormField.SetRichTextBoxText(richTextBoxNotes, videoItem.notes);
if (videoItem.encoding != null)
{
// set width
if (videoItem.encoding.width > 0)
{
MyFormField.SetTextBoxText(textBoxWidth, videoItem.encoding.width.ToString());
}
else
{
MyFormField.SetTextBoxText(textBoxWidth, "");
}
// set height
if (videoItem.encoding.height > 0)
{
MyFormField.SetTextBoxText(textBoxHeight, videoItem.encoding.height.ToString());
}
else
{
MyFormField.SetTextBoxText(textBoxHeight, "");
}
// set bitrate
if (videoItem.encoding.bitrate > 0)
{
MyFormField.SetTextBoxText(textBoxBitrate, videoItem.encoding.bitrate.ToString());
string bitrateFormatted = MyFile.FormatSize(videoItem.encoding.bitrate, 2);
bitrateFormatted = bitrateFormatted.Replace(" ", "\n");
MyFormField.SetLabelText(labelForBitrateFormatted, bitrateFormatted);
}
else
{
MyFormField.SetTextBoxText(textBoxBitrate, "");
MyFormField.SetLabelText(labelForBitrateFormatted, "");
}
// set codec
if (!String.IsNullOrEmpty(videoItem.encoding.codec))
{
MyFormField.SetComboBoxValue(comboBoxCodec, videoItem.encoding.codec);
}
else
{
MyFormField.SetComboBoxValue(comboBoxCodec, "");
}
}
// set tag
for (int index = dataGridViewTags.Rows.Count - 1; index >= 0; index--)
{
if (dataGridViewTags.Rows[index].IsNewRow)
{
continue;
}
dataGridViewTags.Rows.RemoveAt(index);
}
if (videoItem.tags != null)
{
IComparer <VideoItemTag <string> > sortVideoItemTag = new SortVideoItemTag();
videoItem.tags.Sort(sortVideoItemTag);
foreach (VideoItemTag <string> tag in videoItem.tags)
{
dataGridViewTags.Rows.Add(new object[] { tag.name });
}
// prevent add row from being auto selected
if (dataGridViewTags.CurrentCell != null)
{
dataGridViewTags.CurrentCell.Selected = false;
}
}
// set genre
for (int index = dataGridViewGenres.Rows.Count - 1; index >= 0; index--)
{
if (dataGridViewGenres.Rows[index].IsNewRow)
{
continue;
}
dataGridViewGenres.Rows.RemoveAt(index);
}
if (videoItem.genres != null)
{
IComparer <VideoItemGenre <string> > sortVideoItemGenre = new SortVideoItemGenre();
videoItem.genres.Sort(sortVideoItemGenre);
foreach (VideoItemGenre <string> genre in videoItem.genres)
{
dataGridViewGenres.Rows.Add(new object[] { genre.name });
}
// prevent add row from being auto selected
if (dataGridViewGenres.CurrentCell != null)
{
dataGridViewGenres.CurrentCell.Selected = false;
}
}
// set bing link
SetLinkLabelFromTitle(linkLabelBing, "https://www.bing.com/search?q=");
// set google link
SetLinkLabelFromTitle(linkLabelGoogle, "https://www.google.com/search?q=");
// set google link
SetLinkLabelFromTitle(linkLabelRT, "https://www.rottentomatoes.com/search/?search=");
// set upc
MyFormField.SetTextBoxText(textBoxUPC, videoItem.upc);
// set tmdbId link
MyFormField.SetTextBoxText(textBoxTMDB, videoItem.tmdbId);
MyFormField.SetLinkLabel(linkLabelTMDB, "http://www.themoviedb.org/movie/", videoItem.tmdbId);
// set imdbId link
MyFormField.SetTextBoxText(textBoxIMDB, videoItem.imdbId);
MyFormField.SetLinkLabel(linkLabelIMDB, "http://www.imdb.com/title/", videoItem.imdbId);
// set year
MyFormField.SetComboBoxValue(comboBoxYear, videoItem.year);
// set imdbRating
MyFormField.SetComboBoxValue(comboBoxIMDBRating, Convert.ToInt32(videoItem.imdbRating));
// set mpaa
MyFormField.SetComboBoxValue(comboBoxMPAA, videoItem.mpaa);
// set playCount
MyFormField.SetComboBoxValue(comboBoxPlayCount, videoItem.playCount);
// set rating
MyFormField.SetComboBoxValue(comboBoxRating, videoItem.rating);
// set source
MyFormField.SetComboBoxValue(comboBoxSource, videoItem.source);
// set version
MyFormField.SetComboBoxValue(comboBoxVersion, videoItem.version);
// set lastPlayed
MyFormField.SetLabelText(labelLastPlayed, videoItem.lastPlayed);
// set labelUpdated
MyFormField.SetLabelText(labelUpdated, videoInfo.updated);
// set watched
MyFormField.SetCheckBoxChecked(checkBoxWatched, ((videoItem.watched != "NO") ? true : false));
// set actor/director
for (int index = dataGridViewActors.Rows.Count - 1; index >= 0; index--)
{
if (dataGridViewActors.Rows[index].IsNewRow)
{
continue;
}
dataGridViewActors.Rows.RemoveAt(index);
}
if (videoItem.directors != null)
{
IComparer <VideoItemDirector <string> > sortVideoItemDirector = new SortVideoItemDirector();
videoItem.directors.Sort(sortVideoItemDirector);
foreach (VideoItemDirector <string> director in videoItem.directors)
{
dataGridViewActors.Rows.Add(new object[] { director.name, "Director" });
}
}
if (videoItem.actors != null)
{
IComparer <VideoItemActor <string, string> > sortVideoItemActor = new SortVideoItemActor();
videoItem.actors.Sort(sortVideoItemActor);
foreach (VideoItemActor <string, string> actor in videoItem.actors)
{
dataGridViewActors.Rows.Add(new object[] { actor.name, actor.role });
}
}
// prevent add row from being auto selected
if (dataGridViewActors.CurrentCell != null)
{
dataGridViewActors.CurrentCell.Selected = false;
}
}
catch (Exception e)
{
MyLog.Add(e.ToString());
}
this.Parent.Focus();
}
public void PlayFile_Completed(object sender, VideoItemFileInfo resultsVideoItemFileInfo, VideoInfo playedVideoInfo)
{
}
public static GalleryImageThumbnailInfo GetCachedThumbnail(VideoInfo videoInfo)
{
GalleryImageThumbnailInfo galleryImageThumbnailInfo = new GalleryImageThumbnailInfo();
galleryImageThumbnailInfo.fromCache = false;
galleryImageThumbnailInfo.createdCache = false;
galleryImageThumbnailInfo.thumbnail = null;
Image thumbnail = null;
string cachedThumbnailFullName = MyFile.EnsureDataFile("poster_" + videoInfo.hash, "jpg", @"cache\gallery");
if (Config.settings.gallery.cachePosterThumbnails && File.Exists(cachedThumbnailFullName))
{
// use file stream so files not locked
FileStream fileStream = new FileStream(cachedThumbnailFullName, FileMode.Open, FileAccess.Read);
thumbnail = Image.FromStream(fileStream);
fileStream.Close();
// thumbnail = Image.FromFile(cachedThumbnailFile); // locks file
galleryImageThumbnailInfo.fromCache = true;
}
else if (videoInfo.files.poster == null)
{
thumbnail = null;
}
else
{
VideoItemFile videoItemFile = videoInfo.files.poster;
string posterFullName = videoInfo.GetFullName(videoItemFile);
// skip images smaller than y or larger than x
if (videoItemFile.Length < 100)
{
MyLog.Add("Get Thumbnail: Skipping " + posterFullName + " " + MyFile.FormatSize(videoItemFile.Length));
thumbnail = null;
}
if (videoItemFile.Length > 5 * 1048576)
{
MyLog.Add("Get Thumbnail: Skipping " + posterFullName + " " + MyFile.FormatSize(videoItemFile.Length));
thumbnail = null;
}
try
{
if (!File.Exists(posterFullName))
{
thumbnail = null;
}
else
{
// size of thumbails .. TODO make a config setting
thumbnail = MyImage.GetThumbnail(posterFullName, 165, 250, Color.Black);
if (Config.settings.gallery.cachePosterThumbnails && thumbnail != null)
{
// clone image so files not locked
if (MyImage.SaveJpgImage((Image)thumbnail.Clone(), cachedThumbnailFullName))
{
galleryImageThumbnailInfo.createdCache = true;
}
}
}
}
catch (OutOfMemoryException)
{
// Image.FromFile will throw this if file is invalid/corrupted; Don't ask me why
MyLog.Add("Invalid Image; Unable to read " + posterFullName + " " + MyFile.FormatSize(videoItemFile.Length));
thumbnail = null;
}
catch (Exception ei)
{
MyLog.Add(ei.ToString());
thumbnail = null;
}
}
galleryImageThumbnailInfo.thumbnail = thumbnail;
return(galleryImageThumbnailInfo);
}
/// <summary>
/// filter video items
/// </summary>
/// <param name="videoItem"></param>
/// <param name="filterInfo"></param>
/// <returns>true, remove item; false, keep item</returns>
private bool VideoInfoFilter(VideoInfo videoInfo, FilterInfo filterInfo)
{
if (videoInfo == null || videoInfo.videoItem == null)
{
return(true);
}
VideoItem videoItem = videoInfo.videoItem;
bool logFiltered = false; // for debug; log i/o slows down filter
string message = "";
if (filterInfo.filterType == 1)
{
// filter by combo boxes
if (VideoItemFilterContainsString(videoItem.title, filterInfo.title))
{
return(true);
}
if (VideoItemFilterBetweenInt(videoItem.year, filterInfo.yearFrom, filterInfo.yearTo))
{
return(true);
}
if (VideoItemFilterBetweenInt(videoItem.playCount, filterInfo.playCountFrom, filterInfo.playCountTo))
{
return(true);
}
if (VideoItemFilterWatched(videoItem.watched, filterInfo.watched))
{
return(true);
}
if (VideoItemFilterEqualString(videoItem.source, filterInfo.source))
{
return(true);
}
if (VideoItemFilterEqualString(videoItem.mpaa, filterInfo.mpaa))
{
return(true);
}
// MyLog.Add("title"+videoItem.searchTitle+ " vtag:" + videoItem.tag + " ftag:"+ filterInfo.tag);
if (videoItem.tags != null &&
VideoItemFilterContainsString(String.Join(",", videoItem.tags), filterInfo.tag, true))
{
return(true);
}
}
else if (filterInfo.filterType == 0)
{
// filtler by tag cloud
if (logFiltered)
{
message = videoItem.title;
}
if (VideoItemFilterContainsString(videoItem.title, filterInfo.title))
{
if (logFiltered)
{
MyLog.Add("FILTER : " + message + " title:" + videoItem.title + " filter:" + filterInfo.title);
}
return(true);
}
if (!String.IsNullOrEmpty(filterInfo.year) && videoItem.year == 0)
{
return(true);
}
if (VideoItemFilterContainsString(filterInfo.year, videoItem.year.ToString()))
{
if (logFiltered)
{
MyLog.Add("FILTER : " + message + " year:" + videoItem.year + " filter:" + filterInfo.year);
}
return(true);
}
if (VideoItemFilterContainsString(filterInfo.playCount, videoItem.playCount.ToString()))
{
if (logFiltered)
{
MyLog.Add("FILTER : " + message + " playCount:" + videoItem.playCount + " filter:" + filterInfo.playCount);
}
return(true);
}
if (VideoItemFilterWatched(videoItem.watched, filterInfo.watched))
{
if (logFiltered)
{
MyLog.Add("FILTER : " + message + " watched:" + videoItem.watched + " filter:" + filterInfo.watched);
}
return(true);
}
if (VideoItemFilterContainsString(filterInfo.source, videoItem.source))
{
if (logFiltered)
{
MyLog.Add("FILTER : " + message + " source:" + videoItem.source + " filter:" + filterInfo.source);
}
return(true);
}
if (VideoItemFilterContainsString(filterInfo.sourceAlias, videoInfo.sourceAlias))
{
if (logFiltered)
{
MyLog.Add("FILTER : " + message + " sourceAlias:" + videoInfo.sourceAlias + " filter:" + filterInfo.sourceAlias);
}
return(true);
}
if (VideoItemFilterContainsString(filterInfo.mpaa, videoItem.mpaa))
{
if (logFiltered)
{
MyLog.Add("FILTER : " + message + " mpaa:" + videoItem.mpaa + " filter:" + filterInfo.mpaa);
}
return(true);
}
if (videoItem.tags != null)
{
string tags = String.Join(",", videoItem.tags);
if (VideoItemFilterContainsString(filterInfo.tag, tags))
{
if (logFiltered)
{
MyLog.Add("FILTER : " + message + " tags:" + tags + " filter:" + filterInfo.tag);
}
return(true);
}
}
}
return(false);
}
/// <summary>
/// read the video directory and try to parse video info
/// such as XBMC, MB
/// </summary>
/// <param name="directory"></param>
/// <returns></returns>
public VideoInfo ReadDirectory(string directory)
{
bool parsedFile = false;
VideoInfo videoInfo = new VideoInfo();
videoInfo.Initialize();
videoInfo.videoDirectory = directory;
VideoInfo parsedVideoInfo = new VideoInfo();
parsedVideoInfo.Initialize();
parsedVideoInfo.videoDirectory = directory;
IEnumerable <string> files = MyFile.EnumerateFiles(directory);
if (files.Count() == 0)
{
// empty folder .. maybe a category folder, or movie placeholder
return(videoInfo);
}
// MyLog.Add("ReadDirectory: " + files.Count() + " files");
foreach (string file in files)
{
FileInfo fileInfo = MyFile.FileInfo(file);
if (fileInfo == null)
{
continue;
}
VideoItemFile videoItemFile = new VideoItemFile();
videoItemFile.Set(directory, fileInfo);
// parse nfo/xml/file to get file info
videoInfo.files.qty += 1;
string fileExt = fileInfo.Extension.TrimStart('.');
switch (fileExt)
{
case "avi":
case "m4v":
case "mov":
case "mpg":
case "mkv":
case "mp4":
case "mpeg":
videoInfo.files.video = videoItemFile;
//if (videoInfo.videoItem.encoding == null)
//{
string encoding = RunFFprobe(videoInfo.GetFullName(videoInfo.files.video));
if (encoding != null)
{
videoInfo.videoItem.encoding = ParseFFprobe(encoding);
}
//}
break;
case "jpg":
case "jpeg":
case "png":
if (fileInfo.Name == "poster.jpg")
{
videoInfo.files.poster = videoItemFile;
}
else if (fileInfo.Name == "fanart.jpg")
{
videoInfo.files.fanart = videoItemFile;
}
videoInfo.files.images.Add(videoItemFile);
break;
case "mve":
case "nfo":
case "xml":
// TODO btr way to ensure which type parsing
string fileContents = MyFile.ReadAllText(fileInfo.FullName);
fileContents = fileContents.Trim();
if (String.IsNullOrEmpty(fileContents))
{
continue;
}
if (fileContents.StartsWith("<?xml"))
{
XmlDocument doc = MyXMLDoc.LoadXml(fileContents);
if (doc == null)
{
continue;
}
if (fileContents.Contains("<VideoInfo>"))
{
//if (parsedFile == false)
{
parsedVideoInfo = ParseMVE(fileInfo.FullName);
videoInfo.MergeVideoItemWith(parsedVideoInfo);
// videoInfo.videoItem = parsedVideoInfo.videoItem;
}
videoInfo.files.mve = videoItemFile;
parsedFile = true;
}
if (fileContents.Contains("<Title>"))
{
//if (parsedFile == false)
{
parsedVideoInfo = ParseMB(doc);
videoInfo.MergeVideoItemWith(parsedVideoInfo);
//videoInfo.videoItem = parsedVideoInfo.videoItem;
}
videoInfo.files.mb = videoItemFile;
parsedFile = true;
}
if (fileContents.Contains("<movie>"))
{
//if (parsedFile == false)
{
parsedVideoInfo = ParseXBMC(doc);
videoInfo.MergeVideoItemWith(parsedVideoInfo);
//videoInfo.videoItem = parsedVideoInfo.videoItem;
}
videoInfo.files.xbmc = videoItemFile;
parsedFile = true;
}
}
else if (fileContents.StartsWith("{"))
{
//if (parsedFile == false)
{
parsedVideoInfo = ParseMVE(fileInfo.FullName);
videoInfo.MergeVideoItemWith(parsedVideoInfo);
// videoInfo.videoItem = parsedVideoInfo.videoItem;
}
videoInfo.files.mve = videoItemFile;
parsedFile = true;
}
break;
case "txt":
if (videoItemFile.Name.StartsWith("handbrake"))
{
parsedVideoInfo = ParseOtherHandrake(videoInfo.GetFullName(videoItemFile), videoItemFile);
videoInfo.MergeVideoItemWith(parsedVideoInfo);
}
else
{
parsedVideoInfo = ParseOtherFileName(videoInfo.GetFullName(videoItemFile), videoItemFile);
videoInfo.MergeVideoItemWith(parsedVideoInfo);
}
videoInfo.files.others.Add(videoItemFile);
break;
default:
videoInfo.files.others.Add(videoItemFile);
break;
} // end switch ext
} // end foreach file
// couldnt parse nfo/xml and have video file in dir, so use video file for some basic info
if (!parsedFile && videoInfo.files != null && videoInfo.files.video != null)
{
parsedVideoInfo = ParseVideoFile(videoInfo.files.video);
videoInfo.MergeVideoItemWith(parsedVideoInfo);
parsedFile = true;
}
/* .. no video file .. so skip
* // couldnt parse nfo/xml and have files in dir, so use dir for some basic info
* else if (!parsedFile && files.Count() > 0)
* {
* DirectoryInfo directoryInfo = new DirectoryInfo(directory);
* parsedVideoInfo = ParseDirectory(directoryInfo);
* videoInfo.MergeVideoItemWith(parsedVideoInfo);
*
* parsedFile = true;
* }
*/
if (videoInfo.videoItem.title == null || videoInfo.files == null || videoInfo.files.video == null)
{
videoInfo = null;
}
else
{
// sanitize some data
// remove (year) from title .. bad prior parse mb, xbmc
videoInfo.videoItem.title = Regex.Replace(videoInfo.videoItem.title, @"\([0-9]{4}\)$", "");
}
return(videoInfo);
}
/// <summary>
/// parse the XBMC .nfo file
/// </summary>
/// <param name="doc"></param>
/// <returns></returns>
public VideoInfo ParseXBMC(XmlDocument doc)
{
VideoInfo videoInfo = new VideoInfo();
videoInfo.Initialize();
List <string> innerTexts;
videoInfo.videoItem.title = MyXMLDoc.GetSingleNodeString(doc, "/movie/title");
videoInfo.videoItem.plot = MyXMLDoc.GetSingleNodeString(doc, "/movie/plot");
videoInfo.videoItem.movieset = MyXMLDoc.GetSingleNodeString(doc, "/movie/set");
videoInfo.videoItem.tagline = MyXMLDoc.GetSingleNodeString(doc, "/movie/tagline");
videoInfo.videoItem.imdbId = MyXMLDoc.GetSingleNodeString(doc, "/movie/id");
videoInfo.videoItem.tmdbId = MyXMLDoc.GetSingleNodeString(doc, "/movie/tmdbId");
videoInfo.videoItem.mpaa = MyXMLDoc.GetSingleNodeString(doc, "/movie/mpaa");
videoInfo.videoItem.imdbRating = MyXMLDoc.GetSingleNodeDecimal(doc, "/movie/rating");
videoInfo.videoItem.year = MyXMLDoc.GetSingleNodeInt(doc, "/movie/year");
videoInfo.videoItem.runtime = MyXMLDoc.GetSingleNodeInt(doc, "/movie/runtime");
videoInfo.videoItem.playCount = MyXMLDoc.GetSingleNodeInt(doc, "/movie/playcount");
int watched = MyXMLDoc.GetSingleNodeInt(doc, "/movie/watched");
if (watched != 0 && watched != 1)
{
watched = 0;
}
videoInfo.videoItem.watched = VideoFileEnums.watched.GetKeyByValue(watched);
videoInfo.videoItem.encoding = new VideoEncoding();
videoInfo.videoItem.encoding.codec = MyXMLDoc.GetSingleNodeString(doc, "/movie/fileinfo/streamdetails/video/codec");
videoInfo.videoItem.encoding.width = MyXMLDoc.GetSingleNodeInt(doc, "/movie/fileinfo/streamdetails/video/width");
videoInfo.videoItem.encoding.height = MyXMLDoc.GetSingleNodeInt(doc, "/movie/fileinfo/streamdetails/video/height");
innerTexts = MyXMLDoc.GetMultipleNodeString(doc, "/movie/director");
videoInfo.videoItem.directors = new List <VideoItemDirector <string> > {
};
foreach (string innerText in innerTexts)
{
videoInfo.videoItem.directors.Add(new VideoItemDirector <string>(innerText));
}
innerTexts = MyXMLDoc.GetMultipleNodeString(doc, "/movie/genre");
videoInfo.videoItem.genres = new List <VideoItemGenre <string> > {
};
foreach (string innerText in innerTexts)
{
videoInfo.videoItem.genres.Add(new VideoItemGenre <string>(innerText));
}
innerTexts = MyXMLDoc.GetMultipleNodeString(doc, "/movie/tag");
videoInfo.videoItem.tags = new List <VideoItemTag <string> > {
};
foreach (string innerText in innerTexts)
{
videoInfo.videoItem.tags.Add(new VideoItemTag <string>(innerText));
}
videoInfo.videoItem.actors = new List <VideoItemActor <string, string> >();
List <Dictionary <string, string> > actorInfos = MyXMLDoc.GetMultipleNestedNodeString(doc, "/movie/actor");
foreach (Dictionary <string, string> actorInfo in actorInfos)
{
VideoItemActor <string, string> videoItemActor = new VideoItemActor <string, string>();
foreach (KeyValuePair <string, string> info in actorInfo)
{
switch (info.Key)
{
case "name":
videoItemActor.name = info.Value;
break;
case "role":
videoItemActor.role = info.Value;
break;
case "thumb":
break;
default:
break;
}
}
if (!String.IsNullOrEmpty(videoItemActor.name))
{
videoInfo.videoItem.actors.Add(videoItemActor);
}
}
return(videoInfo);
}
