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);
        }
示例#4
0
        public bool SyncUpVideoSource(FileInfo sourceFileInfo)
        {
            // clean up old uploads
            IEnumerable <string> files = MyFile.EnumerateFiles(@"sync", "*.gz");

            foreach (string file in files)
            {
                MyFile.DeleteFile(file);
            }

            // compress file, video source
            string compressedFile = @"sync\" + MyFile.SafeFileName(sourceFileInfo.Name);

            if (!MyFile.Compress(sourceFileInfo.FullName, compressedFile))
            {
                return(false);
            }

            // rename file so has 'rand' key/iv
            Random random     = new Random();
            int    rand       = random.Next(0, MyEncrypt.sharedKeys.Length - 1);
            string uploadFile = compressedFile.Replace("." + Config.settings.exportExt, "-" + rand + "." + Config.settings.exportExt);

            File.Move(compressedFile + ".gz", uploadFile + ".gz");



            string key       = MyEncrypt.sharedKeys[rand];
            string iv        = MyEncrypt.GenerateIV();
            string delimiter = "#";

            // now encrypt compressed file contents
            string fileContents = MyFile.ReadAllBinaryToString(uploadFile + ".gz");

            string contentsHeader = "{";

            contentsHeader += "\"apiKey\":\"" + this.apiKey + "\", ";
            contentsHeader += "\"iv\":\"" + iv + "\", ";
            contentsHeader += "\"sync\":" + MySerialize.ToJSON(Sync.syncSettings);
            contentsHeader += "}";

            contentsHeader = Convert.ToBase64String(Encoding.UTF8.GetBytes(contentsHeader));



            fileContents = MyEncrypt.EncryptRJ256(key, iv, fileContents);
            if (fileContents == null)
            {
                return(false);
            }

            contentsHeader = MyEncrypt.EncryptRJ256(key, iv, contentsHeader);

            string contentsToEncode = contentsHeader + delimiter + fileContents;

            // write base64 encoded file
            File.WriteAllText(uploadFile + ".enc", contentsToEncode);


            // log it
            FileInfo encodedFileInfo = MyFile.FileInfo(uploadFile + ".enc");

            if (encodedFileInfo == null)
            {
                return(false);
            }
            MyLog.Add(String.Format("Encrypted {0} to {1}", encodedFileInfo.Name, MyFile.FormatSize(encodedFileInfo.Length)));


            // test decrypt

            fileContents = MyFile.ReadAllText(uploadFile + ".enc");

            string[] fileParts = fileContents.Split(new string[] { delimiter }, StringSplitOptions.None);

            fileContents = MyEncrypt.DecryptRJ256(key, iv, fileParts[1]);



            MyFile.DeleteFile(uploadFile + ".gz");
            MyFile.WriteAllBinaryFromString(uploadFile + ".gz", fileContents);



            // post encoded file to website

            string url = apiURL;
            List <KeyValuePair <string, string> > headers = new List <KeyValuePair <string, string> > {
            };

            headers.Add(new KeyValuePair <string, string>("api-key", apiKey));
            headers.Add(new KeyValuePair <string, string>("access-token", iv));
            Upload(url, uploadFile + ".enc", headers);



            return(true);
        }
示例#5
0
        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();
        }
示例#6
0
 private void FormMain_FormClosed(object sender, FormClosedEventArgs e)
 {
     MyLog.Add("========================================== Closed application");
 }
示例#7
0
        public bool SetList()
        {
            listViewSyncUp.SuspendLayout();

            listViewSyncUp.Items.Clear();

            // string syncFile;
            string       fileSize;
            FileInfo     fileInfo;
            ListViewItem listViewItem;

            /*
             * // get sync info
             * syncFile = @"sync\sync." + Config.settings.exportExt;
             * fileInfo = MyFile.FileInfo(syncFile);
             * if (fileInfo == null)
             * {
             *  Sync.Save();
             *  fileInfo = MyFile.FileInfo(syncFile);
             *  if (fileInfo == null)
             *  {
             *      MessageBox.Show("Unable to create [" + syncFile + "]");
             *      MyLog.Add("Unable to create [" + syncFile + "]");
             *      return false;
             *  }
             * }
             * listViewItem = new ListViewItem("Sync");
             * listViewItem.SubItems.Add("-");
             * fileSize = Convert.ToString(MyFile.FormatSize(fileInfo.Length));
             * listViewItem.SubItems.Add(fileSize);
             * listViewItem.Tag = fileInfo;
             *
             * listViewSyncUp.Items.Add(listViewItem);
             */

            // get all sources
            IEnumerable <string> files = MyFile.EnumerateFiles("data", "videos_*." + Config.settings.exportExt);
            Regex regexIgnoreBackups   = new Regex(@"\.[0-9]\." + Config.settings.exportExt);

            foreach (string file in files)
            {
                if (regexIgnoreBackups.IsMatch(file))
                {
                    continue;
                }
                fileInfo = MyFile.FileInfo(file);
                if (fileInfo == null)
                {
                    continue;
                }
                string source = file.Replace(@"data\videos_", "").Replace("." + Config.settings.exportExt, "");
                int    qty    = CalcStatsForSource(source);
                if (qty == 0)
                {
                    MyLog.Add("Source [" + source + "] seems to have 0 videos, skipping");
                    continue;
                }
                listViewItem = new ListViewItem(source);
                listViewItem.SubItems.Add(qty.ToString());
                fileSize = Convert.ToString(MyFile.FormatSize(fileInfo.Length));
                listViewItem.SubItems.Add(fileSize);
                listViewItem.Tag = fileInfo;

                listViewSyncUp.Items.Add(listViewItem);
            }


            ResizeColumns();


            listViewSyncUp.ResumeLayout();

            return(true);
        }
示例#8
0
        protected void BackgroundWorkerRunFile_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            VideoItemFileInfo resultsVideoItemFileInfo = null;

            // First, handle the case where an exception was thrown.
            if (e.Error != null)
            {
                MyLog.Add(e.Error.ToString());
                subFormProgress.Text(e.Error.Message);
            }
            else if (e.Cancelled)
            {
                // Next, handle the case where the user canceled the operation.
                // Note that due to a race condition in the DoWork event handler, the Cancelled
                // flag may not have been set, even though CancelAsync was called.
                subFormProgress.Text("Canceled");
            }
            else
            {
                // Finally, handle the case where the operation  succeeded.
                resultsVideoItemFileInfo = (VideoItemFileInfo)e.Result;
                if (resultsVideoItemFileInfo != null)
                {
                    MyLog.Add("Played: " + resultsVideoItemFileInfo.videoItemFile.Name + " for " + resultsVideoItemFileInfo.elapsed + "s");
                }
                else
                {
                    MyLog.Add("Played: no results: " + e.ToString());
                }


                long elapsed = resultsVideoItemFileInfo.elapsed;

                // kinda simple check to make sure updating video that was played
                if (subFormVideoForm.selectedVideoInfo.files != null &&
                    subFormVideoForm.selectedVideoInfo.files.video != null &&
                    resultsVideoItemFileInfo.videoItemFile != null &&
                    subFormVideoForm.selectedVideoInfo.files.video.Name == resultsVideoItemFileInfo.videoItemFile.Name)
                {
                    subFormProgress.Text("Done playing..");

                    // MyLog.Add("elapsed:"+elapsed+" watchedAfter:" + (Config.settings.watchedAfter));

                    // if played for more than X minutes, assumed "watched"
                    if (Config.settings.markWatched && elapsed > Config.settings.watchedAfter)
                    {
                        subFormProgress.Value(90);
                        subFormProgress.Text("Updating watched..");

                        subFormVideoForm.SetWatched();

                        subFormVideoForm.SaveForm();
                    }

                    subFormProgress.Value(0);
                    subFormProgress.Text("Ready");
                }

                subFormProgress.Value(0);
                subFormProgress.Text("Ready");
            }

            // bubble the event up
            EventHandler <VideoItemFileInfo> handler = this.playFile_Completed;

            if (handler != null)
            {
                MessageBox.Show("bubble");
                handler(this, resultsVideoItemFileInfo);
            }
        }
示例#9
0
        /// <summary>
        /// background process getting VideoInfos completed
        /// used for ScanSource and FilterSource
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void VideoInfos_RunWorkerCompleted(string action, string message, object sender, RunWorkerCompletedEventArgs e)
        {
            // First, handle the case where an exception was thrown.
            if (e.Error != null)
            {
                MyLog.Add(e.Error.ToString());
                subFormProgress.Text(e.Error.Message);
            }
            else if (e.Cancelled)
            {
                // Next, handle the case where the user canceled the operation.
                // Note that due to a race condition in the DoWork event handler, the Cancelled
                // flag may not have been set, even though CancelAsync was called.
                subFormProgress.Text("Canceled");
            }
            else
            {
                // Finally, handle the case where the operation  succeeded.

                if (action == "scan")
                {
                    List <VideoInfosScanSource> videoInfosScanSources = (List <VideoInfosScanSource>)e.Result;

                    if (videoInfosScanSources == null)
                    {
                        MyLog.Add(message + " Null VideoItems");
                        MyLog.AddElapsed(stopwatch.Elapsed);
                        LoadVideos_Completed(sender, e);
                        return;
                    }

                    MyLog.Add(message);
                    MyLog.AddElapsed(stopwatch.Elapsed);

                    subFormProgress.Text("Applying..");
                    subFormProgress.Value(0);
                    int nbrAppliedSources = 0;
                    int nbrSourcesToApply = videoInfosScanSources.Count();
                    foreach (VideoInfosScanSource videoInfosScanSource in videoInfosScanSources)
                    {
                        MyLog.Add("Applying " + videoInfosScanSource.sourceAlias + " with " + videoInfosScanSource.videoInfos.Count().ToString() + " VideoItems");

                        int progress = (int)Math.Floor((decimal)(nbrSourcesToApply - nbrAppliedSources) / nbrSourcesToApply * 100);
                        subFormProgress.Text("Applying " + videoInfosScanSource.sourceAlias + "..");
                        subFormProgress.Value(progress);

                        // sources scanned less than settings,
                        // so remove scanned sources from existing list
                        // and replace with scanned list
                        List <VideoInfo> currentVideoInfos = ListVideoInfo.GetList();
                        if (currentVideoInfos == null)
                        {
                            ListVideoInfo.SetList(videoInfosScanSource.videoInfos);
                        }
                        else
                        {
                            currentVideoInfos.RemoveAll(s => s.sourceAlias == videoInfosScanSource.sourceAlias);

                            currentVideoInfos.AddRange(videoInfosScanSource.videoInfos);
                            ListVideoInfo.SetList(currentVideoInfos);
                        }
                        // videoInfos = videoInfos.Union(currentVideoInfos).ToList();

                        nbrAppliedSources++;
                    }
                }
                else // filter
                {
                    List <VideoInfo> videoInfos = (List <VideoInfo>)e.Result;

                    if (videoInfos == null)
                    {
                        MyLog.Add(message + " Null VideoItems");
                        MyLog.AddElapsed(stopwatch.Elapsed);
                        LoadVideos_Completed(sender, e);
                        return;
                    }

                    MyLog.Add(message + " " + videoInfos.Count().ToString() + " VideoItems");
                    MyLog.AddElapsed(stopwatch.Elapsed);
                    subFormProgress.Text("Applying..");
                    subFormProgress.Value(0);

                    ListVideoInfo.SetList(videoInfos);
                }

                MyLog.Add("Setting List");
                subFormProgress.Value(0);
                subFormProgress.Text("Setting List..");
                subFormListView.SetListViewInfos(ListVideoInfo.GetList());
                Application.DoEvents(); // meh, not needed but allow ui redraw


                if (Config.settings.gallery.enable)
                {
                    MyLog.Add("Building Gallery");
                    subFormProgress.Text("Building Gallery..");
                    subFormProgress.Value(0);
                    stopwatchBuildGalleryImages = Stopwatch.StartNew(); // stopped when background worker completed
                    // build to either create thumbnails or get existing thumbnails
                    // will call LoadVideos_Completed() via RunCalcStats() when done
                    buildGalleryImages.Build(ListVideoInfo.GetList());
                }
                else
                {
                    RunCalcStats(sender, e);
                }
            }
        }
示例#10
0
        public bool SaveFilter(string filterName)
        {
            if (filterName.Length == 0)
            {
                return(false);
            }
            string dataFile;

            if (filterName == "<_reset_>")
            {
                MessageBox.Show("Cannot Save filter");
                subFormFilterForm.ResetForm();
                return(false);
            }
            else if (filterName == "<filter when closed>")
            {
                dataFile = MyFile.EnsureDataFile("Filter", Config.settings.exportExt, "filters", "filter when closed");
                if (dataFile == null)
                {
                    return(false);
                }
            }
            else if (filterName == "<last saved filter>")
            {
                MessageBox.Show("Cannot Save filter.\nThis Filter will be automaticlly be saved when you Save another Filter.");
                return(false);
            }
            else
            {
                filterName = MyFile.SafeFileName(filterName);
                dataFile   = MyFile.EnsureDataFile("Filter", Config.settings.exportExt, "filters", filterName);
                if (dataFile == null)
                {
                    return(false);
                }
                allow_comboBoxPreset_SelectedIndexChanged = false;
                comboBoxFilters.Text = filterName;
                allow_comboBoxPreset_SelectedIndexChanged = true;
            }

            FilterInfo filterInfo = subFormFilterForm.GetFilterForm();

            MyLog.RotateFiles(dataFile);

            filterInfo.about = Config.GetConfigSettingsAbout();
            filterInfo.name  = filterName;
            if (filterInfo.description == null)
            {
                filterInfo.description = "";
            }

            MySerialize.ToFile(Config.settings.exportFormat, dataFile, filterInfo);

            MyLog.Add("Saved Filter Preset " + dataFile.Replace(MyFile.exeDirectory, ""));

            // make a copy of last saved filter
            if (filterName != "<last saved filter>" && filterName != "<filter when closed>")
            {
                dataFile = MyFile.EnsureDataFile("Filter", Config.settings.exportExt, "filters", "last saved filter");
                if (dataFile == null)
                {
                    return(false);
                }
                MyLog.RotateFiles(dataFile);


                MySerialize.ToFile(Config.settings.exportFormat, dataFile, filterInfo);
                MyLog.Add("Saved Filter Preset " + dataFile.Replace(MyFile.exeDirectory, ""));
            }


            return(true);
        }
示例#11
0
        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);
        }
示例#13
0
        private string RunFFprobe(string videoFilePath)
        {
            Process process  = null;
            string  encoding = null;
            string  error    = null;

            if (!File.Exists(videoFilePath))
            {
                // MyLog.Add("Video not found " + fileInfo.FullName);
                return(encoding);
            }

            string ffprobeExe = MyFile.EnsureDataFile("ffprobe", "exe", @"libs/ffmpeg/bin");

            if (!File.Exists(ffprobeExe))
            {
                // MyLog.Add("FFMPEG: not found " + ffprobeExe);
                return(encoding);
            }


            try
            {
                encodingFFProbeError  = "";
                encodingFFProbeOutput = "";

                string workingDirectory = MyFile.exeDirectory; // MyFile.exeDirectory + "/temp";  // MyFile.exeDirectory;
                string arguments        = string.Format("-v warning -show_error -show_format -show_streams -print_format xml \"{0}\"", videoFilePath);

                // MyLog.Add("RunFFprobe: Start " + videoItemFile.FullName + ": \"" + ffprobeExe + "\" " + arguments);

                ProcessStartInfo startInfo = new ProcessStartInfo();
                startInfo.FileName               = ffprobeExe;
                startInfo.Arguments              = arguments;
                startInfo.CreateNoWindow         = true;
                startInfo.RedirectStandardOutput = true;
                startInfo.RedirectStandardError  = true;
                startInfo.UseShellExecute        = false;
                startInfo.WorkingDirectory       = workingDirectory;

                process                     = new Process();
                process.StartInfo           = startInfo;
                process.OutputDataReceived += RunFFprobe_Output;
                process.ErrorDataReceived  += RunFFprobe_Error;
                // use this order of events to avoid deadlock
                // http://msdn.microsoft.com/en-us/library/system.diagnostics.process.standardoutput.aspx
                // http://msdn.microsoft.com/en-us/library/system.diagnostics.process.outputdatareceived%28v=vs.110%29.aspx
                process.Start();
                // StreamReader streamReaderError = process.StandardError;
                // encoding = process.StandardError.ReadToEnd();
                // process.BeginOutputReadLine();

                // encoding = process.StandardOutput.ReadToEnd(); // works, simplier


                process.BeginOutputReadLine();
                process.BeginErrorReadLine(); // so far doesnt seem to catch errors


                process.WaitForExit(5000);

                if (!String.IsNullOrEmpty(encodingFFProbeError))
                {
                    MyLog.Add("RunFFprobe: Error on " + videoFilePath + " : " + encodingFFProbeError);
                }
                encoding = encodingFFProbeOutput.Trim();

                // clean up temp folder occasionaly
                Random random = new Random();
                int    chance = random.Next(0, 100);
                if (false && chance < 25)
                {
                    string[] ffprobeLogs = Directory.GetFiles(workingDirectory, "ffprobe*.log");
                    foreach (string ffprobeLog in ffprobeLogs)
                    {
                        File.Delete(ffprobeLog);
                    }
                }
            }
            catch (Exception e)
            {
                MyLog.Add("RunFFprobe: " + e.ToString());
            }


            // MyLog.Add("RunFFprobe: Finish " + videoItemFile.FullName + ": " + encoding);
            try
            {
                string status;
                if (process.ExitCode == 0)
                {
                    status = "Success";
                }
                else
                {
                    status = "Error";
                }
                MyLog.Add("RunFFprobe: " + status + " code:" + process.ExitCode.ToString() + " probed in:" + process.TotalProcessorTime.Milliseconds.ToString() + "ms");
            }
            catch (Exception)
            {
            }
            if (error != null)
            {
                MyLog.Add(error);
            }

            if (process != null)
            {
                process.Close();
            }

            // meh, throttle some
            Thread.Sleep(10);

            return(encoding);
        }
示例#14
0
        public void SetFilterForm(FilterInfo filterInfo)
        {
            try
            {
                if (filterInfo.filterType == 1)
                {
                }
                else if (filterInfo.filterType == 0)
                {
                    foreach (KeyValuePair <string, string> type in criteriaTypes)
                    {
                        string selectedTags = null;

                        switch (type.Key)
                        {
                        case "height":
                            if (String.IsNullOrEmpty(filterInfo.height))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.height;
                            break;

                        case "imdbRating":
                            if (String.IsNullOrEmpty(filterInfo.imdbRating))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.imdbRating;
                            break;

                        case "mpaa":
                            if (String.IsNullOrEmpty(filterInfo.mpaa))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.mpaa;
                            break;

                        case "playCount":
                            if (String.IsNullOrEmpty(filterInfo.playCount))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.playCount;
                            break;

                        case "rating":
                            if (String.IsNullOrEmpty(filterInfo.rating))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.rating;
                            break;

                        case "source":
                            if (String.IsNullOrEmpty(filterInfo.source))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.source;
                            break;

                        case "tag":
                            if (String.IsNullOrEmpty(filterInfo.tag))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.tag;
                            break;

                        case "watched":
                            if (filterInfo.watched == "ANY")
                            {
                                selectedTags  = VideoFileEnums.watched.GetTextByKey("YES");
                                selectedTags += ",";
                                selectedTags += VideoFileEnums.watched.GetTextByKey("NO");
                            }
                            else if (!VideoFileEnums.watched.KeyExists(filterInfo.watched))
                            {
                                continue;
                            }
                            else
                            {
                                selectedTags = VideoFileEnums.watched.GetTextByKey(filterInfo.watched);
                            }
                            break;

                        case "width":
                            if (String.IsNullOrEmpty(filterInfo.height))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.width;
                            break;

                        case "year":
                            if (String.IsNullOrEmpty(filterInfo.year))
                            {
                                continue;
                            }
                            selectedTags = filterInfo.year;
                            break;

                        default:
                            continue;
                        }
                        AddCriteria(type.Key, selectedTags);
                    }
                }
            }
            catch (Exception e)
            {
                MyLog.Add("SetFilterForm: " + e.ToString());
            }
        }