Example #1
0
        public static bool Save(Form formMain)
        {
            // save main window size/position
            settings.window.left   = formMain.Left;
            settings.window.top    = formMain.Top;
            settings.window.height = formMain.Height;
            settings.window.width  = formMain.Width;

            // save maximized state
            settings.window.maximized = formMain.WindowState == FormWindowState.Maximized ? true : false;

            // set modified, version
            settings.about = GetConfigSettingsAbout();

            string configFile = MyFile.EnsureDataFile("settings", settings.exportExt, "config");

            if (configFile == null)
            {
                return(false);
            }

            MyLog.RotateFiles(configFile);

            // save new settings
            MySerialize.ToFile(settings.exportFormat, configFile, settings);

            return(true);
        }
Example #2
0
        public static bool Load()
        {
            bool ret = true;



            string syncFile = MyFile.EnsureDataFile("sync", Config.settings.exportExt, "sync");

            if (File.Exists(syncFile))
            {
                // load settings
                syncSettings = (SyncSettings)MyDeserialize.FromFile(Config.settings.exportFormat, syncFile, syncSettings);

                if (syncSettings.guid == null || syncSettings.about == null)
                {
                    syncSettings.Initialize();
                }
            }
            else
            {
                syncSettings.Initialize();
            }


            return(ret);
        }
 private void tabControlSettings_SelectedIndexChanged(object sender, EventArgs e)
 {
     if (tabControlSettings.SelectedIndex == 1)
     {
         // meta data tab
     }
     else if (tabControlSettings.SelectedIndex == 2)
     {
         // external tab
         string ffprobeExe = MyFile.EnsureDataFile("ffprobe", "exe", @"libs/ffmpeg/bin");
         if (!File.Exists(ffprobeExe))
         {
             labelFFProbeStatus.Text      = "Not Found";
             labelFFProbeStatus.ForeColor = Color.OrangeRed;
         }
         else
         {
             labelFFProbeStatus.Text      = "Available";
             labelFFProbeStatus.ForeColor = Color.ForestGreen;
         }
     }
     else if (tabControlSettings.SelectedIndex == 3)
     {
         SetGalleryCacheSize();
     }
 }
Example #4
0
        public static bool SaveVideoInfo(VideoInfo videoInfo)
        {
            // MyLog.Add("SaveVideoInfo");

            listVideoInfos[videoInfo.index] = videoInfo;

            UpdateVideo updateVideo = new UpdateVideo();

            updateVideo.UpdateMVE(videoInfo);

            updateVideo.UpdateXBMC(videoInfo);

            updateVideo.UpdateMB(videoInfo);


            // delete prior statsfile, if any, so stats will be re-calced
            string statsFile = MyFile.EnsureDataFile("stats", Config.settings.exportExt, "stats");

            if (statsFile != null)
            {
                MyFile.DeleteFile(statsFile);
            }


            return(true);
        }
Example #5
0
        protected bool LoadSelectedFilter()
        {
            if (comboBoxFilters.Items.Count == 0)
            {
                return(false);
            }
            if (subFormFilterForm == null)
            {
                return(false);
            }

            string filterName = comboBoxFilters.Text;

            if (filterName.Length == 0)
            {
                return(false);
            }
            if (filterName == "<_reset_>")
            {
                subFormFilterForm.ResetForm();
                return(true);
            }
            if (filterName == "<filter when closed>")
            {
                filterName = "filter when closed";
            }
            else if (filterName == "<last saved filter>")
            {
                filterName = "last saved filter";
            }

            FilterInfo filterInfo = new FilterInfo(); // subFormFilterForm.GetFilterForm();
            string     dataFile   = MyFile.EnsureDataFile("Filter", Config.settings.exportExt, "filters", filterName);

            // MessageBox.Show(dataFile);
            if (File.Exists(dataFile))
            {
                // load filter preset
                filterInfo = (FilterInfo)MyDeserialize.FromFile(Config.settings.exportFormat, dataFile, filterInfo);

                if (filterInfo == null)
                {
                    MessageBox.Show("Unable to load Filter [" + filterName + "]");
                    return(false);
                }

                subFormFilterForm.ResetForm();

                subFormFilterForm.SetFilterForm(filterInfo);
                MyLog.Add("Loaded Filter Preset " + dataFile.Replace(MyFile.exeDirectory, ""));

                return(true);
            }
            return(false);
        }
Example #6
0
        protected void BackgroundWorkerScanSource_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            // delete prior statsfile, if any, so stats will be re-calced
            string statsFile = MyFile.EnsureDataFile("stats", Config.settings.exportExt, "stats");

            if (statsFile != null)
            {
                MyFile.DeleteFile(statsFile);
            }
            VideoInfos_RunWorkerCompleted("scan", "Scanning done", sender, e);
        }
Example #7
0
        public static bool Save()
        {
            if (listVideoInfos == null)
            {
                return(false);
            }

            Stopwatch stopWatch = new Stopwatch();

            stopWatch.Start();
            MyLog.Add("Saving VideoItems -->");

            foreach (ConfigSettings.Source settingsSource in Config.settings.sources)
            {
                string dataFile = MyFile.EnsureDataFile("videos", Config.settings.exportExt, "data", settingsSource.alias);
                if (dataFile == null)
                {
                    continue;
                }

                List <VideoInfo> saveVideoInfos = new List <VideoInfo>(listVideoInfos.Count());
                saveVideoInfos = listVideoInfos.Where(x => x.sourceAlias == settingsSource.alias && x.videoItem != null && x.videoItem.title != null).OrderBy(x => x.videoItem.title).ToList();


                if (saveVideoInfos == null)
                {
                    continue;
                }
                int nbrVideoInfos = saveVideoInfos.Count();
                if (nbrVideoInfos == 0)
                {
                    continue;
                }

                MyLog.RotateFiles(dataFile);
                MySerialize.ToFile(Config.settings.exportFormat, dataFile, saveVideoInfos);


                FileInfo fileInfo = MyFile.FileInfo(dataFile);
                string   toFile   = "to " + dataFile.Replace(MyFile.exeDirectory, "");
                if (fileInfo != null)
                {
                    toFile += " " + MyFile.FormatSize(fileInfo.Length);
                }
                MyLog.Add("Saved " + nbrVideoInfos + " VideoItems " + toFile);
            }

            stopWatch.Stop();
            MyLog.AddElapsed("<-- in ", stopWatch.Elapsed);

            return(true);
        }
        public static bool Load()
        {
            bool      ret       = false;
            Stopwatch stopWatch = new Stopwatch();

            stopWatch.Start();

            // MyLog.Add("Loading VideoItemStats");

            string dataFile = MyFile.EnsureDataFile("stats", Config.settings.exportExt, "stats");

            if (dataFile == null)
            {
                return(false);
            }

            // keep a backup of settings
            if (File.Exists(dataFile))
            {
                videoInfoStats = new VideoInfoStats();
                videoInfoStats = (VideoInfoStats)MyDeserialize.FromFile(Config.settings.exportFormat, dataFile, videoInfoStats);

                string   fromFIle = "from " + dataFile.Replace(MyFile.exeDirectory, "");
                FileInfo fileInfo = MyFile.FileInfo(dataFile);
                if (fileInfo != null)
                {
                    fromFIle += " " + MyFile.FormatSize(fileInfo.Length);
                }
                MyLog.Add("Loaded VideoInfoStats " + fromFIle);

                if (videoInfoStats != null && videoInfoStats.year != null && videoInfoStats.year.Count() > 0)
                {
                    ret = true;
                }
            }
            else
            {
                // MyLog.Add("No VideoInfoStats to load ");
            }

            stopWatch.Stop();

            if (ret)
            {
                MyLog.AddElapsed(stopWatch.Elapsed);
            }

            return(ret);
        }
        public static bool Save()
        {
            string dataFile = MyFile.EnsureDataFile("stats", Config.settings.exportExt, "stats");

            if (dataFile == null)
            {
                return(false);
            }

            MyLog.RotateFiles(dataFile);

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

            return(true);
        }
Example #10
0
        public static bool Save()
        {
            string syncFile = MyFile.EnsureDataFile("sync", Config.settings.exportExt, "sync");

            if (syncFile == null)
            {
                return(false);
            }

            MyLog.RotateFiles(syncFile);

            // save new settings
            MySerialize.ToFile(Config.settings.exportFormat, syncFile, syncSettings);

            return(true);
        }
Example #11
0
        public bool DeleteFilter(string preset)
        {
            bool ret = false;

            if (MessageBox.Show("Delete Filter Preset [" + preset + "]", "Filter Preset", MessageBoxButtons.YesNo) == DialogResult.Yes)
            {
                string dataFile = MyFile.EnsureDataFile("Filter", Config.settings.exportExt, "filters", preset);
                // MessageBox.Show(dataFile);
                if (MyFile.DeleteFile(dataFile))
                {
                    // MessageBox.Show("Deleted Filter Preset [" + preset + "]");
                    comboBoxFilters.Items.Remove(comboBoxFilters.SelectedItem);
                    LoadFilters();
                    // subFormFilterForm.ResetForm();
                    ret = true;
                }
                else
                {
                    MessageBox.Show("Error deleting Filter Preset [" + preset + "]");
                }
            }
            return(ret);
        }
Example #12
0
        public bool LoadFilters()
        {
            // also ensures directory filter exists
            string dataFile = MyFile.EnsureDataFile("Filter", Config.settings.exportExt, "filters");

            IEnumerable <string> files = MyFile.EnumerateFiles("filters", "Filter_*." + Config.settings.exportExt);

            comboBoxFilters.SuspendLayout();

            comboBoxFilters.Items.Clear();
            comboBoxFilters.Items.Add("<_reset_>");
            comboBoxFilters.Items.Add("<filter when closed>");
            comboBoxFilters.Items.Add("<last saved filter>");
            comboBoxFilters.SelectedIndex = 0;
            if (files.Count() > 0)
            {
                Regex regexIgnoreBackups = new Regex(@"\.[0-9]\." + Config.settings.exportExt);
                foreach (string file in files)
                {
                    if (regexIgnoreBackups.IsMatch(file))
                    {
                        continue;
                    }
                    string filterName = file.Replace(@"filters\", "");
                    filterName = filterName.Replace(@"." + Config.settings.exportExt, "");
                    filterName = filterName.Replace(@"Filter_", "");
                    if (filterName == "_reset_" || filterName == "filter when closed" || filterName == "last saved filter")
                    {
                        continue;
                    }
                    comboBoxFilters.Items.Add(filterName);
                }
            }

            comboBoxFilters.ResumeLayout();
            return(true);
        }
Example #13
0
        /// <summary>
        /// log message to the log file
        /// always log exceptions e.ToString() so can debug/fix
        /// </summary>
        /// <param name="message"></param>
        public static void Add(string message)
        {
            if (logFile == null)
            {
                logFile = MyFile.EnsureDataFile("mve", "log", "logs");
            }

            try
            {
                string privateMemorySize;
                using (Process currentProcess = Process.GetCurrentProcess())
                {
                    privateMemorySize = MyFile.FormatSize(currentProcess.PrivateMemorySize64);
                }

                using (StreamWriter streamWriter = File.AppendText(logFile))
                {
                    streamWriter.WriteLine("{0} | {1} | {2} | ", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ff"), privateMemorySize, message);
                }
            }
            catch (Exception e)
            {
                if (Application.OpenForms.Count > 0)
                {
                    MessageBox.Show("Unable to write to log [" + e.Message + "]");
                }
            }

            // check if should rotate logs; but only check occasionaly, to reduce io checks
            Random random = new Random();

            if (random.Next(1, 100) < 20)
            {
                RotateLogs(logFile);
            }
        }
Example #14
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);
        }
Example #15
0
        public static bool Load()
        {
            Stopwatch stopWatch = new Stopwatch();

            stopWatch.Start();

            MyLog.Add("Loading VideoItems -->");

            int      nbrVideoInfos;
            FileInfo fileInfo;

            CreateList();
            foreach (ConfigSettings.Source source in Config.settings.sources)
            {
                string dataFile = MyFile.EnsureDataFile("videos", Config.settings.exportExt, "data", source.alias);
                if (dataFile == null)
                {
                    continue;
                }

                // keep a backup of settings
                if (File.Exists(dataFile))
                {
                    fileInfo = MyFile.FileInfo(dataFile);
                    List <VideoInfo> loadVideoInfos = (List <VideoInfo>)MyDeserialize.FromFile(Config.settings.exportFormat, dataFile, listVideoInfos);
                    if (loadVideoInfos == null)
                    {
                        MyLog.Add("Unable to load VideoInfos from " + dataFile);
                        continue;
                    }
                    AddItems(loadVideoInfos);

                    string fromFile = "from " + dataFile.Replace(MyFile.exeDirectory, "");
                    if (fileInfo != null)
                    {
                        fromFile += " " + MyFile.FormatSize(fileInfo.Length);
                    }

                    if (loadVideoInfos == null)
                    {
                        nbrVideoInfos = 0;
                    }
                    else
                    {
                        nbrVideoInfos = loadVideoInfos.Count();
                    }
                    MyLog.Add("Loaded " + nbrVideoInfos + " VideoItems " + fromFile);
                }
            }

            EnsureVideoInfos();

            stopWatch.Stop();


            if (listVideoInfos == null)
            {
                nbrVideoInfos = 0;
            }
            else
            {
                nbrVideoInfos = listVideoInfos.Count();
            }

            MyLog.AddElapsed("<-- in ", stopWatch.Elapsed);

            bool loaded = nbrVideoInfos > 0 ? true : false;

            return(loaded);
        }
Example #16
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);
        }
Example #17
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);
        }
Example #18
0
        public static bool Load(Form mainForm)
        {
            bool ret = true;

            // app non configurable, so far, settings
            settings.exportFormat = "json";
            settings.exportExt    = "json"; // chicken egg


            string configFile    = MyFile.EnsureDataFile("settings", settings.exportExt, "config");
            bool   bLoadDefaults = false;

            if (File.Exists(configFile))
            {
                // load settings
                settings = (ConfigSettings)MyDeserialize.FromFile(settings.exportFormat, configFile, settings);
            }
            else
            {
                bLoadDefaults = true;
                ret           = false;
            }
            if (settings == null || settings.sources == null || settings.window == null || settings.gallery == null)
            {
                bLoadDefaults = true;
                ret           = false;
            }
            else
            {
                if (settings.window.left > 0 &&
                    settings.window.top > 0 &&
                    settings.window.height > 0 &&
                    settings.window.width > 0)
                {
                    // restore position/size
                    mainForm.Left   = settings.window.left;
                    mainForm.Top    = settings.window.top;
                    mainForm.Height = settings.window.height;
                    mainForm.Width  = settings.window.width;
                }

                if (settings.window.maximized == true)
                {
                    // restore to maximized state
                    mainForm.WindowState = FormWindowState.Maximized;
                }
            }

            // could not load settings, so set minimal defaults
            if (bLoadDefaults)
            {
                // meh, check all for defaults
            }

            // ensure other settings exist, else default
            if (settings == null)
            {
                settings      = new ConfigSettings();
                bLoadDefaults = true;
            }
            if (settings.sources == null)
            {
                settings.sources = new List <ConfigSettings.Source>();;
            }

            if (settings.gallery == null)
            {
                settings.gallery = new ConfigSettings.Gallery();
                bLoadDefaults    = true;
            }
            if (settings.gallery.backColor == Color.Empty)
            {
                settings.gallery.backColor = Color.DarkSlateBlue;
            }

            if (bLoadDefaults)
            {
                settings.gallery.enable = false;
                settings.gallery.cachePosterThumbnails = true;
            }

            // app non configurable, so far, settings
            settings.exportFormat = "json";
            settings.exportExt    = "json";

            return(ret);
        }