StartAndLoad() public method

public StartAndLoad ( string File, bool TraceSyscalls = false, bool ShowMenus = true, bool TrackCallStack = true, bool EnableMpeg = null ) : void
File string
TraceSyscalls bool
ShowMenus bool
TrackCallStack bool
EnableMpeg bool
return void
Esempio n. 1
0
        static unsafe void Main(string[] Arguments)
        {
            //Console.WriteLine(GL.GetConstantString(GL.GL_TEXTURE_2D));
            //_MainData();
            //_MainData2();

            if (!IsNet45OrNewer())
            {
                MessageBox.Show(".NET 4.5 required", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                return;
            }

            // Add the event handler for handling UI thread exceptions to the event.
            Application.ThreadException += new ThreadExceptionEventHandler(Form1_UIThreadException);

            // Set the unhandled exception mode to force all Windows Forms errors to go through
            // our handler.
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // Add the event handler for handling non-UI thread exceptions to the event.
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

            Logger.OnGlobalLog += (LogName, Level, Text, StackFrame) =>
            {
                if (Level >= Logger.Level.Info)
                {
                    var Method = StackFrame.GetMethod();
                    Console.WriteLine("{0} : {1} : {2}.{3} : {4}", LogName, Level, (Method.DeclaringType != null) ? Method.DeclaringType.Name : null, Method.Name, Text);
                }
            };

            #if false
            Console.WriteLine(CSPspEmu.Resources.Translations.GetString("extra", "UnknownGame"));
            Console.ReadKey(); Environment.Exit(0);
            #endif

            #if RUN_TESTS
            RunTests(Arguments);
            #endif

            string FileToLoad = null;
            bool RunTestsViewOut = false;
            int RunTestsTimeout = 60;

            var Getopt = new Getopt(Arguments);
            {
                Getopt.AddRule(new[] { "/help", "/?", "-h", "--help", "-?" }, () =>
                {
                    Console.WriteLine("Soywiz's Psp Emulator - {0} - r{1} - {2}", PspGlobalConfiguration.CurrentVersion, PspGlobalConfiguration.CurrentVersionNumeric, PspGlobalConfiguration.GitRevision);
                    Console.WriteLine("");
                    Console.WriteLine(" Switches:");
                    Console.WriteLine("   /version                         - Outputs the program version");
                    Console.WriteLine("   /version2                        - Outputs the program numeric version");
                    Console.WriteLine("   /decrypt <EBOOT.BIN>             - Decrypts an EBOOT.BIN");
                    Console.WriteLine("   /gitrevision                     - Outputs the git revision");
                    Console.WriteLine("   /associate                       - Associates extensions with the program. Requires be launched with administrative rights.");
                    Console.WriteLine("   /viewout /timeout X /tests       - Run integration tests.");
                    Console.WriteLine("   ");
                    Console.WriteLine("   /isolist <pathto.iso|cso|dax>    - Lists the content of an iso.");
                    Console.WriteLine("   /isoextract <in.iso> <outfolder> - Extracts the content of an iso.");
                    Console.WriteLine("   /isoconvert <in.xxx> <out.yyy>   - Converts a iso/cso/dax file into other format.");
                    Console.WriteLine("");
                    Console.WriteLine(" Examples:");
                    Console.WriteLine("   cspspemu.exe <path_to_psp_executable>");
                    Console.WriteLine("");
                    Environment.Exit(0);
                });
                Getopt.AddRule("/version", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.CurrentVersion);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/version2", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.CurrentVersionNumeric);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/isoconvert", () =>
                {
                    var IsoInPath = Getopt.DequeueNext();
                    var IsoOutPath = Getopt.DequeueNext();

                    if (Path.GetExtension(IsoOutPath) != ".iso")
                    {
                        Console.WriteLine("Just support outputing .iso files");
                        Environment.Exit(-1);
                    }

                    var IsoInFile = IsoLoader.GetIso(IsoInPath);
                    var Stopwatch = new Stopwatch();
                    Stopwatch.Start();
                    Console.Write("{0} -> {1}...", IsoInPath, IsoOutPath);
                    IsoInFile.Stream.Slice().CopyToFile(IsoOutPath);
                    Console.WriteLine("Ok ({0})", Stopwatch.Elapsed);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/isolist", () =>
                {
                    var IsoPath = Getopt.DequeueNext();
                    var IsoFile = IsoLoader.GetIso(IsoPath);
                    var IsoFileSystem = new HleIoDriverIso(IsoFile);
                    foreach (var FileName in IsoFileSystem.ListDirRecursive("/"))
                    {
                        var Stat = IsoFileSystem.GetStat(FileName);
                        Console.WriteLine("{0} : {1}", FileName, Stat.Size);
                    }
                    //Console.Write("{0}", PspGlobalConfiguration.CurrentVersionNumeric);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/isoextract", () =>
                {
                    var IsoPath = Getopt.DequeueNext();
                    var OutputPath = Getopt.DequeueNext();
                    var IsoFile = IsoLoader.GetIso(IsoPath);
                    var IsoFileSystem = new HleIoDriverIso(IsoFile);
                    foreach (var FileName in IsoFileSystem.ListDirRecursive("/"))
                    {
                        var Stat = IsoFileSystem.GetStat(FileName);
                        var OutputFileName = OutputPath + "/" + FileName;
                        Console.Write("{0} : {1}...", FileName, Stat.Size);

                        if (!Stat.Attributes.HasFlag(Hle.Vfs.IOFileModes.Directory))
                        {
                            var ParentDirectory = Directory.GetParent(OutputFileName).FullName;
                            //Console.WriteLine(ParentDirectory);
                            try { Directory.CreateDirectory(ParentDirectory); }
                            catch
                            {
                            }
                            using (var InputStream = IsoFileSystem.OpenRead(FileName))
                            {
                                InputStream.CopyToFile(OutputFileName);
                            }
                        }
                        Console.WriteLine("Ok");
                    }
                    //Console.Write("{0}", PspGlobalConfiguration.CurrentVersionNumeric);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/decrypt", (string EncryptedFile) =>
                {
                    try
                    {
                        using (var EncryptedStream = File.OpenRead(EncryptedFile))
                        {
                            var DecryptedFile = String.Format("{0}.decrypted", EncryptedFile);
                            Console.Write("'{0}' -> '{1}'...", EncryptedFile, DecryptedFile);

                            var EncryptedData = EncryptedStream.ReadAll();
                            var DecryptedData = new EncryptedPrx().Decrypt(EncryptedData);
                            File.WriteAllBytes(DecryptedFile, DecryptedData);
                            Console.WriteLine("Ok");
                            Environment.Exit(0);
                        }
                    }
                    catch (Exception Exception)
                    {
                        Console.Error.WriteLine(Exception);
                        Environment.Exit(-1);
                    }
                });
                Getopt.AddRule("/gitrevision", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.GitRevision);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/associate", () =>
                {
                    try
                    {
                        Registry.ClassesRoot.CreateSubKey(".pbp").SetValue(null, "cspspemu.executable");
                        Registry.ClassesRoot.CreateSubKey(".elf").SetValue(null, "cspspemu.executable");
                        Registry.ClassesRoot.CreateSubKey(".prx").SetValue(null, "cspspemu.executable");
                        Registry.ClassesRoot.CreateSubKey(".cso").SetValue(null, "cspspemu.executable");
                        Registry.ClassesRoot.CreateSubKey(".dax").SetValue(null, "cspspemu.executable");

                        var Reg = Registry.ClassesRoot.CreateSubKey("cspspemu.executable");
                        Reg.SetValue(null, "PSP executable file (.elf, .pbp, .cso, .prx, .dax)");
                        Reg.SetValue("DefaultIcon", @"""" + ApplicationPaths.ExecutablePath + @""",0");
                        Reg.CreateSubKey("shell").CreateSubKey("open").CreateSubKey("command").SetValue(null, @"""" + ApplicationPaths.ExecutablePath + @""" ""%1""");

                        Environment.Exit(0);
                    }
                    catch (Exception Exception)
                    {
                        Console.Error.WriteLine(Exception);
                        Environment.Exit(-1);
                    }
                });
                Getopt.AddRule("/viewout", () =>
                {
                    RunTestsViewOut = true;
                });
                Getopt.AddRule("/timeout", (int seconds) =>
                {
                    RunTestsTimeout = seconds;
                });
                Getopt.AddRule("/tests", () =>
                {
                    RunTests(RunTestsViewOut, Getopt.DequeueAllNext(), RunTestsTimeout);
                });
                Getopt.AddRule((Name) =>
                {
                    FileToLoad = Name;
                });
            }
            try
            {
                Getopt.Process();
            }
            catch (Exception Exception)
            {
                Console.Error.WriteLine(Exception);
                Environment.Exit(-1);
            }

            Logger.Info("Running ... plat:{0} ... int*:{1}", Environment.Is64BitProcess ? "64bit" : "32bit", sizeof(int*));
            {
                var MonoRuntimeType = Type.GetType("Mono.Runtime");
                if (MonoRuntimeType != null)
                {
                    var GetDisplayNameMethod = MonoRuntimeType.GetMethod("GetDisplayName", BindingFlags.NonPublic | BindingFlags.Static);
                    if (GetDisplayNameMethod != null) Console.WriteLine("Mono: {0}", GetDisplayNameMethod.Invoke(null, null));
                }
            }
            Console.WriteLine("ImageRuntimeVersion: {0}", Assembly.GetExecutingAssembly().ImageRuntimeVersion);

            #if !RELEASE
            try
            {
                Console.OutputEncoding = Encoding.UTF8;
                Console.SetWindowSize(160, 60);
                Console.SetBufferSize(160, 2000);
            }
            catch
            {
            }
            #endif

            /*
            foreach (var NI in NetworkInterface.GetAllNetworkInterfaces())
            {
                if (NI.SupportsMulticast && NI.OperationalStatus == OperationalStatus.Up)
                {
                    var IPProperties = NI.GetIPProperties();
                    Console.WriteLine("[A]:{0}", NI.ToStringDefault());
                    foreach (var Item in IPProperties.DhcpServerAddresses)
                    {
                        Console.WriteLine("[B]:{0},{1}", Item.ToString(), Item.IsIPv6Multicast);
                    }
                    foreach (var Item in IPProperties.AnycastAddresses)
                    {
                        Console.WriteLine("[D]:{0}", Item.Address.ToString());
                    }
                    foreach (var Item in IPProperties.MulticastAddresses)
                    {
                        Console.WriteLine("[E]:{0}", Item.Address.ToString());
                    }
                    foreach (var Item in IPProperties.UnicastAddresses)
                    {
                        Console.WriteLine("[F]:{0}", Item.Address.ToString());
                    }
                    Console.WriteLine("[G]:{0}", NI.GetPhysicalAddress());
                }
                else
                {
                    Console.WriteLine("-");
                }
            }
            */

            using (var PspEmulator = new PspEmulator())
            {
                //PspEmulator.UseFastMemory = true;
                var CodeBase = Assembly.GetExecutingAssembly().Location;
                var Base = Path.GetDirectoryName(CodeBase) + @"\" + Path.GetFileNameWithoutExtension(CodeBase);
                foreach (var TryExtension in new[] { "iso", "cso", "elf", "pbp" })
                {
                    var TryIsoFile = Base + "." + TryExtension;

                    //Console.WriteLine(TryIsoFile);
                    //Console.ReadKey();

                    if (File.Exists(TryIsoFile))
                    {
                        Platform.HideConsole();

                        PspEmulator.StartAndLoad(TryIsoFile, TraceSyscalls: false, ShowMenus: false);
                        return;
                    }
                }

                if (FileToLoad != null)
                {
                    PspEmulator.StartAndLoad(FileToLoad, TraceSyscalls: false);
                }
                else
                {
                    //StartWithoutArguments(PspEmulator);
                    PspEmulator.Start();
                }
            }
        }
Esempio n. 2
0
        static void Main(string[] Arguments)
        {
            // Add the event handler for handling UI thread exceptions to the event.
            Application.ThreadException += new ThreadExceptionEventHandler(Form1_UIThreadException);

            // Set the unhandled exception mode to force all Windows Forms errors to go through
            // our handler.
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // Add the event handler for handling non-UI thread exceptions to the event.
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

            /*
            IntPtr playback_handle = IntPtr.Zero;
            IntPtr hw_params = IntPtr.Zero;
            Alsa.snd_config_t config;
            int rate = 44100;
            Console.WriteLine(Alsa.snd_pcm_open(&playback_handle, "default", Alsa.snd_pcm_stream_t.SND_PCM_LB_OPEN_PLAYBACK, 0));
            Console.WriteLine(Alsa.snd_pcm_hw_params_malloc(&hw_params));
            Console.WriteLine(Alsa.snd_pcm_hw_params_any(playback_handle, hw_params));

            Console.WriteLine(Alsa.snd_pcm_hw_params_set_access(playback_handle, hw_params, Alsa.snd_pcm_access.SND_PCM_ACCESS_RW_INTERLEAVED));
            Console.WriteLine(Alsa.snd_pcm_hw_params_set_format(playback_handle, hw_params, Alsa.snd_pcm_format.SND_PCM_FORMAT_S16_LE));
            Console.WriteLine(Alsa.snd_pcm_hw_params_set_rate_near(playback_handle, hw_params, &rate, null));
            Console.WriteLine(Alsa.snd_pcm_hw_params_set_channels (playback_handle, hw_params, 2));
            Console.WriteLine(Alsa.snd_pcm_hw_params(playback_handle, hw_params));
            Console.WriteLine(Alsa.snd_pcm_hw_params_free(hw_params));

            var Data = new byte[16 * 1024];
            for (int n = 0; n < Data.Length; n++)
            {
                Data[n] = (byte)n;
            }
            fixed (byte* DataPtr = Data)
            {
                Alsa.snd_pcm_writei(playback_handle, DataPtr, Data.Length / 4);
            }

            Thread.Sleep(128);

            //Console.WriteLine(Alsa.snd_pcm_prepare(playback_handle));
            //Console.WriteLine(Alsa.snd_pcm_open_preferred(out AlsaHandle, null, null, (int)Alsa.OpenMode.SND_PCM_LB_OPEN_PLAYBACK));
            //Console.WriteLine(Alsa.snd_pcm_close(AlsaHandle));
            Environment.Exit(0); return;
            */

            Logger.OnGlobalLog += (LogName, Level, Text, StackFrame) =>
            {
                if (Level >= Logger.Level.Info)
                {
                    var Method = StackFrame.GetMethod();
                    Console.WriteLine("{0} : {1} : {2}.{3} : {4}", LogName, Level, Method.DeclaringType.Name, Method.Name, Text);
                }
            };

            Logger.Info("Running ... plat:{0} ... int*:{1}", Environment.Is64BitProcess ? "x64" : "x86", sizeof(int*));
            #if false
            Console.WriteLine(CSPspEmu.Resources.Translations.GetString("extra", "UnknownGame"));
            Console.ReadKey(); Environment.Exit(0);
            #endif

            #if RUN_TESTS
            TestsAutoProgram.Main(Arguments.Skip(0).ToArray());
            Environment.Exit(0);
            #endif
            //AppDomain.UnHandledException
            /*
            AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
            {
                try
                {
                    Console.Error.WriteLine(e.ExceptionObject);
                }
                catch
                {
                }
                Console.ReadKey();
                Environment.Exit(-1);
            };
            */

            //Application.EnableVisualStyles(); Application.Run(new GameListForm()); Application.Exit();

            string FileToLoad = null;

            var Getopt = new Getopt(Arguments);
            {
                Getopt.AddRule(new[] { "/help", "/?", "-h", "--help", "-?" }, () =>
                {
                    Console.WriteLine("Soywiz's Psp Emulator - {0} - r{1} - {2}", PspGlobalConfiguration.CurrentVersion, PspGlobalConfiguration.CurrentVersionNumeric, PspGlobalConfiguration.GitRevision);
                    Console.WriteLine("");
                    Console.WriteLine(" Switches:");
                    Console.WriteLine("   /version             - Outputs the program version");
                    Console.WriteLine("   /version2            - Outputs the program numeric version");
                    Console.WriteLine("   /decrypt <EBOOT.BIN> - Decrypts an EBOOT.BIN");
                    Console.WriteLine("   /gitrevision         - Outputs the git revision");
                    Console.WriteLine("   /installat3          - Installs the WavDest filter. Requires be launched with administrative rights.");
                    Console.WriteLine("   /associate           - Associates extensions with the program. Requires be launched with administrative rights.");
                    Console.WriteLine("   /tests               - Run integration tests.");
                    Console.WriteLine("");
                    Console.WriteLine(" Examples:");
                    Console.WriteLine("   cspspemu.exe <path_to_psp_executable>");
                    Console.WriteLine("");
                    Environment.Exit(0);
                });
                Getopt.AddRule("/version", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.CurrentVersion);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/version2", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.CurrentVersionNumeric);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/decrypt", (string EncryptedFile) =>
                {
                    try
                    {
                        using (var EncryptedStream = File.OpenRead(EncryptedFile))
                        {
                            /*
                            var Format = new FormatDetector().DetectSubType(EncryptedStream);

                            switch (Format)
                            {
                                case FormatDetector.SubType.Cso:
                                case FormatDetector.SubType.Dax:
                                case FormatDetector.SubType.Iso:

                                    break;
                            }
                            */

                            var DecryptedFile = String.Format("{0}.decrypted", EncryptedFile);
                            Console.Write("'{0}' -> '{1}'...", EncryptedFile, DecryptedFile);

                            var EncryptedData = EncryptedStream.ReadAll();
                            var DecryptedData = new EncryptedPrx().Decrypt(EncryptedData);
                            File.WriteAllBytes(DecryptedFile, DecryptedData);
                            Console.WriteLine("Ok");
                            Environment.Exit(0);
                        }
                    }
                    catch (Exception Exception)
                    {
                        Console.Error.WriteLine(Exception);
                        Environment.Exit(-1);
                    }
                });
                Getopt.AddRule("/gitrevision", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.GitRevision);
                    Environment.Exit(0);
                });
                Getopt.AddRule("/installat3", () =>
                {
                    var OutFile = Environment.SystemDirectory + @"\WavDest.dll";
                    File.WriteAllBytes(OutFile, Assembly.GetEntryAssembly().GetManifestResourceStream("CSPspEmu.WavDest.dll").ReadAll());
                    Process.Start(new ProcessStartInfo("regsvr32", String.Format(@"/s ""{0}"" ", OutFile))).WaitForExit();
                    Environment.Exit(0);
                });
                Getopt.AddRule("/associate", () =>
                {
                    try
                    {
                        Registry.ClassesRoot.CreateSubKey(".elf").SetValue(null, "cspspemu.executable");
                        Registry.ClassesRoot.CreateSubKey(".pbp").SetValue(null, "cspspemu.executable");
                        Registry.ClassesRoot.CreateSubKey(".cso").SetValue(null, "cspspemu.executable");
                        Registry.ClassesRoot.CreateSubKey(".prx").SetValue(null, "cspspemu.executable");
                        Registry.ClassesRoot.CreateSubKey(".dax").SetValue(null, "cspspemu.executable");

                        var Reg = Registry.ClassesRoot.CreateSubKey("cspspemu.executable");
                        Reg.SetValue(null, "PSP executable file (.elf, .pbp, .cso, .prx, .dax)");
                        Reg.SetValue("DefaultIcon", @"""" + ApplicationPaths.ExecutablePath + @""",0");
                        Reg.CreateSubKey("shell").CreateSubKey("open").CreateSubKey("command").SetValue(null, @"""" + ApplicationPaths.ExecutablePath + @""" ""%1""");

                        Environment.Exit(0);
                    }
                    catch (Exception Exception)
                    {
                        Console.Error.WriteLine(Exception);
                        Environment.Exit(-1);
                    }
                });
                Getopt.AddRule("/tests", () =>
                {
                    TestsAutoProgram.Main(Arguments.Skip(1).ToArray());
                    Environment.Exit(0);
                });
                Getopt.AddRule((Name) =>
                {
                    FileToLoad = Name;
                });
            }
            try
            {
                Getopt.Process();
            }
            catch (Exception Exception)
            {
                Console.Error.WriteLine(Exception);
                Environment.Exit(-1);
            }
            //new PspAudioOpenalImpl().__TestAudio();
            //new PspAudioWaveOutImpl().__TestAudio();
            //return;

            /*
            var CsoName = "../../../TestInput/test.cso";
            var Cso = new Cso(File.OpenRead(CsoName));
            var Iso = new IsoFile();
            Console.WriteLine("[1]");
            Iso.SetStream(new CsoProxyStream(Cso), CsoName);
            Console.WriteLine("[2]");
            foreach (var Node in Iso.Root.Descendency())
            {
                Console.WriteLine(Node);
            }
            Console.ReadKey();
            return;
            */

            #if !RELEASE
            try
            {
                Console.OutputEncoding = Encoding.UTF8;
                Console.SetWindowSize(160, 60);
                Console.SetBufferSize(160, 2000);
            }
            catch
            {
            }
            #endif
            var PspEmulator = new PspEmulator();
            //PspEmulator.UseFastMemory = true;
            var CodeBase = Assembly.GetExecutingAssembly().Location;
            var Base = Path.GetDirectoryName(CodeBase) + @"\" + Path.GetFileNameWithoutExtension(CodeBase);
            foreach (var TryExtension in new[] { "iso", "cso", "elf", "pbp" })
            {
                var TryIsoFile = Base + "." + TryExtension;

                //Console.WriteLine(TryIsoFile);
                //Console.ReadKey();

                if (File.Exists(TryIsoFile))
                {
                    Platform.HideConsole();

                    PspEmulator.StartAndLoad(TryIsoFile, TraceSyscalls: false, ShowMenus: false);
                    return;
                }
            }

            if (FileToLoad != null)
            {
                PspEmulator.StartAndLoad(FileToLoad, TraceSyscalls: false);
            }
            else
            {
                //StartWithoutArguments(PspEmulator);
                PspEmulator.Start();
            }
        }
Esempio n. 3
0
        static void DoMain(string[] arguments)
        {
            //Console.WriteLine(GL.GetConstantString(GL.GL_TEXTURE_2D));
            //_MainData();
            //_MainData2();

            if (!IsNet45OrNewer())
            {
                //ThreadManForUser.MessageBox.Show(".NET 4.5 required", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                return;
            }

            // Add the event handler for handling UI thread exceptions to the event.
            //Application.ThreadException += new ThreadExceptionEventHandler(Form1_UIThreadException);

            //System.AppDomain.CurrentDomain.UnhandledException +=

            // Set the unhandled exception mode to force all Windows Forms errors to go through
            // our handler.
            //Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

            // Add the event handler for handling non-UI thread exceptions to the event.
            AppDomain.CurrentDomain.UnhandledException +=
                new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

            Logger.OnGlobalLog += (logName, level, text, stackFrame) =>
            {
                if (level >= Logger.Level.Info)
                {
                    var method = stackFrame.GetMethod();
                    Console.WriteLine("{0} : {1} : {2}.{3} : {4}", logName, level,
                                      method.DeclaringType != null ? method.DeclaringType.Name : null, method.Name, text);
                }
            };

#if false
            Console.WriteLine(CSPspEmu.Resources.Translations.GetString("extra", "UnknownGame"));
            Console.ReadKey(); Environment.Exit(0);
#endif

#if RUN_TESTS
            RunTests(Arguments);
#endif

            string fileToLoad      = null;
            bool   runTestsViewOut = false;
            int    runTestsTimeout = 60;

            var getopt = new Getopt(arguments);
            {
                getopt.AddRule(new[] { "/help", "/?", "-h", "--help", "-?" }, () =>
                {
                    Console.WriteLine("Soywiz's Psp Emulator - {0} - r{1} - {2}", PspGlobalConfiguration.CurrentVersion,
                                      PspGlobalConfiguration.CurrentVersionNumeric, PspGlobalConfiguration.GitRevision);
                    Console.WriteLine("");
                    Console.WriteLine(" Switches:");
                    Console.WriteLine("   /version                         - Outputs the program version");
                    Console.WriteLine("   /version2                        - Outputs the program numeric version");
                    Console.WriteLine("   /decrypt <EBOOT.BIN>             - Decrypts an EBOOT.BIN");
                    Console.WriteLine("   /gitrevision                     - Outputs the git revision");
                    Console.WriteLine(
                        "   /associate                       - Associates extensions with the program. Requires be launched with administrative rights.");
                    Console.WriteLine("   /viewout /timeout X /tests       - Run integration tests.");
                    Console.WriteLine("   ");
                    Console.WriteLine("   /isolist <pathto.iso|cso|dax>    - Lists the content of an iso.");
                    Console.WriteLine("   /isoextract <in.iso> <outfolder> - Extracts the content of an iso.");
                    Console.WriteLine(
                        "   /isoconvert <in.xxx> <out.yyy>   - Converts a iso/cso/dax file into other format.");
                    Console.WriteLine("");
                    Console.WriteLine(" Examples:");
                    Console.WriteLine("   cspspemu.exe <path_to_psp_executable>");
                    Console.WriteLine("");
                    Environment.Exit(0);
                });
                getopt.AddRule("/version", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.CurrentVersion);
                    Environment.Exit(0);
                });
                getopt.AddRule("/version2", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.CurrentVersionNumeric);
                    Environment.Exit(0);
                });
                getopt.AddRule("/isoconvert", () =>
                {
                    var isoInPath  = getopt.DequeueNext();
                    var isoOutPath = getopt.DequeueNext();

                    if (Path.GetExtension(isoOutPath) != ".iso")
                    {
                        Console.WriteLine("Just support outputing .iso files");
                        Environment.Exit(-1);
                    }

                    var isoInFile = IsoLoader.GetIso(isoInPath);
                    var stopwatch = new Stopwatch();
                    stopwatch.Start();
                    Console.Write("{0} -> {1}...", isoInPath, isoOutPath);
                    isoInFile.Stream.Slice().CopyToFile(isoOutPath);
                    Console.WriteLine("Ok ({0})", stopwatch.Elapsed);
                    Environment.Exit(0);
                });
                getopt.AddRule("/isolist", () =>
                {
                    var isoPath       = getopt.DequeueNext();
                    var isoFile       = IsoLoader.GetIso(isoPath);
                    var isoFileSystem = new HleIoDriverIso(isoFile);
                    foreach (var fileName in isoFileSystem.ListDirRecursive("/"))
                    {
                        var stat = isoFileSystem.GetStat(fileName);
                        Console.WriteLine("{0} : {1}", fileName, stat.Size);
                    }

                    //Console.Write("{0}", PspGlobalConfiguration.CurrentVersionNumeric);
                    Environment.Exit(0);
                });
                getopt.AddRule("/isoextract", () =>
                {
                    var isoPath       = getopt.DequeueNext();
                    var outputPath    = getopt.DequeueNext();
                    var isoFile       = IsoLoader.GetIso(isoPath);
                    var isoFileSystem = new HleIoDriverIso(isoFile);
                    foreach (var fileName in isoFileSystem.ListDirRecursive("/"))
                    {
                        var stat           = isoFileSystem.GetStat(fileName);
                        var outputFileName = outputPath + "/" + fileName;
                        Console.Write("{0} : {1}...", fileName, stat.Size);

                        if (!stat.Attributes.HasFlag(Hle.Vfs.IOFileModes.Directory))
                        {
                            var parentDirectory = Directory.GetParent(outputFileName).FullName;
                            //Console.WriteLine(ParentDirectory);
                            try
                            {
                                Directory.CreateDirectory(parentDirectory);
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine(e);
                            }

                            using (var inputStream = isoFileSystem.OpenRead(fileName))
                            {
                                inputStream.CopyToFile(outputFileName);
                            }
                        }

                        Console.WriteLine("Ok");
                    }

                    //Console.Write("{0}", PspGlobalConfiguration.CurrentVersionNumeric);
                    Environment.Exit(0);
                });
                getopt.AddRule("/decrypt", (string encryptedFile) =>
                {
                    try
                    {
                        using (var encryptedStream = File.OpenRead(encryptedFile))
                        {
                            var decryptedFile = $"{encryptedFile}.decrypted";
                            Console.Write("'{0}' -> '{1}'...", encryptedFile, decryptedFile);

                            var encryptedData = encryptedStream.ReadAll();
                            var decryptedData = new EncryptedPrx().Decrypt(encryptedData);
                            File.WriteAllBytes(decryptedFile, decryptedData);
                            Console.WriteLine("Ok");
                            Environment.Exit(0);
                        }
                    }
                    catch (Exception exception)
                    {
                        Console.Error.WriteLine(exception);
                        Environment.Exit(-1);
                    }
                });
                getopt.AddRule("/gitrevision", () =>
                {
                    Console.Write("{0}", PspGlobalConfiguration.GitRevision);
                    Environment.Exit(0);
                });
                //getopt.AddRule("/associate", () =>
                //{
                //    try
                //    {
                //        var classesRoot = Registry.ClassesRoot;
//
                //        classesRoot.CreateSubKey(".pbp")?.SetValue(null, "cspspemu.executable");
                //        classesRoot.CreateSubKey(".elf")?.SetValue(null, "cspspemu.executable");
                //        classesRoot.CreateSubKey(".prx")?.SetValue(null, "cspspemu.executable");
                //        classesRoot.CreateSubKey(".cso")?.SetValue(null, "cspspemu.executable");
                //        classesRoot.CreateSubKey(".dax")?.SetValue(null, "cspspemu.executable");
//
                //        var reg = classesRoot.CreateSubKey("cspspemu.executable");
                //        reg?.SetValue(null, "PSP executable file (.elf, .pbp, .cso, .prx, .dax)");
                //        reg?.SetValue("DefaultIcon", @"""" + ApplicationPaths.ExecutablePath + @""",0");
                //        reg?.CreateSubKey("shell")?.CreateSubKey("open")?.CreateSubKey("command")?.SetValue(null,
                //            @"""" + ApplicationPaths.ExecutablePath + @""" ""%1""");
//
                //        Environment.Exit(0);
                //    }
                //    catch (Exception e)
                //    {
                //        Console.Error.WriteLine(e);
                //        Environment.Exit(-1);
                //    }
                //});
                getopt.AddRule("/viewout", () => { runTestsViewOut = true; });
                getopt.AddRule("/timeout", (int seconds) => { runTestsTimeout = seconds; });
                getopt.AddRule("/tests",
                               () => { RunTests(runTestsViewOut, getopt.DequeueAllNext(), runTestsTimeout); });
                getopt.AddRule(name => { fileToLoad = name; });
            }
            try
            {
                getopt.Process();
            }
            catch (Exception e)
            {
                Console.Error.WriteLine(e);
                Environment.Exit(-1);
            }

            Logger.Info("Running ... plat:{0} ... int*:{1}", Environment.Is64BitProcess ? "64bit" : "32bit",
                        sizeof(int *));
            {
                var monoRuntimeType = Type.GetType("Mono.Runtime");
                if (monoRuntimeType != null)
                {
                    var getDisplayNameMethod =
                        monoRuntimeType.GetMethod("GetDisplayName", BindingFlags.NonPublic | BindingFlags.Static);
                    if (getDisplayNameMethod != null)
                    {
                        Console.WriteLine("Mono: {0}", getDisplayNameMethod.Invoke(null, null));
                    }
                }
            }
            Console.WriteLine("ImageRuntimeVersion: {0}", Assembly.GetExecutingAssembly().ImageRuntimeVersion);

//#if !RELEASE
//            try
//            {
//                Console.OutputEncoding = Encoding.UTF8;
//                Console.SetWindowSize(160, 60);
//                Console.SetBufferSize(160, 2000);
//            }
//            catch (Exception e)
//            {
//                Console.WriteLine(e);
//            }
//#endif

            /*
             * foreach (var NI in NetworkInterface.GetAllNetworkInterfaces())
             * {
             *  if (NI.SupportsMulticast && NI.OperationalStatus == OperationalStatus.Up)
             *  {
             *      var IPProperties = NI.GetIPProperties();
             *      Console.WriteLine("[A]:{0}", NI.ToStringDefault());
             *      foreach (var Item in IPProperties.DhcpServerAddresses)
             *      {
             *          Console.WriteLine("[B]:{0},{1}", Item.ToString(), Item.IsIPv6Multicast);
             *      }
             *      foreach (var Item in IPProperties.AnycastAddresses)
             *      {
             *          Console.WriteLine("[D]:{0}", Item.Address.ToString());
             *      }
             *      foreach (var Item in IPProperties.MulticastAddresses)
             *      {
             *          Console.WriteLine("[E]:{0}", Item.Address.ToString());
             *      }
             *      foreach (var Item in IPProperties.UnicastAddresses)
             *      {
             *          Console.WriteLine("[F]:{0}", Item.Address.ToString());
             *      }
             *      Console.WriteLine("[G]:{0}", NI.GetPhysicalAddress());
             *  }
             *  else
             *  {
             *      Console.WriteLine("-");
             *  }
             * }
             */

            using (var pspEmulator = new PspEmulator())
            {
                //PspEmulator.UseFastMemory = true;
                var codeBase = Assembly.GetExecutingAssembly().Location;
                var Base     = Path.GetDirectoryName(codeBase) + @"\" + Path.GetFileNameWithoutExtension(codeBase);
                foreach (var tryExtension in new[] { "iso", "cso", "elf", "pbp" })
                {
                    var tryIsoFile = Base + "." + tryExtension;

                    //Console.WriteLine(TryIsoFile);
                    //Console.ReadKey();

                    if (File.Exists(tryIsoFile))
                    {
                        Platform.HideConsole();

                        pspEmulator.StartAndLoad(tryIsoFile, TraceSyscalls: false, ShowMenus: false);
                        return;
                    }
                }

                if (fileToLoad != null)
                {
                    pspEmulator.StartAndLoad(fileToLoad, TraceSyscalls: false);
                }
                else
                {
                    //StartWithoutArguments(PspEmulator);
                    pspEmulator.Start();
                }
            }
        }