示例#1
0
 public MainWindow(IAppArguments appArguments)
 {
     using var sw = new BenchmarkTimer("MainWindow", Log);
     Log.Debug($"Initializing MainWindow for process {appArguments.ProcessId}");
     InitializeComponent();
     sw.Step($"BAML loaded");
 }
示例#2
0
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            using var sw = new BenchmarkTimer("MainWindow initialization routine", Log);
            Log.Info($"Application startup detected, PID: {Process.GetCurrentProcess().Id}");

            SingleInstanceValidationRoutine(true);

            sw.Step("Registering overlay");
            var micSwitchOverlayDependencyName = "MicSwitchOverlayAllWindows";

            container.RegisterOverlayController(micSwitchOverlayDependencyName, micSwitchOverlayDependencyName);
            var matcher = new RegexStringMatcher().AddToWhitelist(".*");

            container.RegisterWindowTracker(micSwitchOverlayDependencyName, matcher);
            var overlayController       = container.Resolve <IOverlayWindowController>(micSwitchOverlayDependencyName);
            var overlayViewModelFactory =
                container.Resolve <IFactory <IMicSwitchOverlayViewModel, IOverlayWindowController> >();
            var overlayViewModel = overlayViewModelFactory.Create(overlayController).AddTo(Anchors);

            overlayController.RegisterChild(overlayViewModel);

            var mainWindow = container.Resolve <MainWindow.Views.MainWindow>();

            sw.Step($"Main window view initialized");
            var viewController      = new WindowViewController(mainWindow);
            var mainWindowViewModel = container.Resolve <IMainWindowViewModel>(new DependencyOverride <IViewController>(viewController)).AddTo(Anchors);

            sw.Step($"Main window view model resolved");
            mainWindow.DataContext = mainWindowViewModel;
            sw.Step($"Main window view model assigned");
            mainWindow.Show();
            sw.Step($"Main window shown");
        }
示例#3
0
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            InitializeContainer();

            using var sw = new BenchmarkTimer("MainWindow initialization routine", Log);
            Log.Info($"Application startup detected, PID: {Process.GetCurrentProcess().Id}");

            Log.Debug("Resolving squirrel events handler");
            var squirrelEventsHandler = Container.Resolve <ISquirrelEventsHandler>();

            Log.Debug(() => $"Resolved squirrel events handler: {squirrelEventsHandler}");

            SingleInstanceValidationRoutine(true);

            var configProvider = Container.Resolve <IConfigProvider>();
            var defaultConfigProviderStrategy = Container.Resolve <UseDefaultIfFailureConfigProviderStrategy>();

            configProvider.RegisterStrategy(defaultConfigProviderStrategy);
            Log.Debug("Loading initial configuration");
            configProvider.Reload();
            Log.Debug("Initial configuration loaded");

            InitializeUpdateSettings();

            sw.Step("Actualizing configuration format");
            Log.Debug("Initializing config provider");
            var hotkeyConfigProvider  = Container.Resolve <IConfigProvider <MicSwitchHotkeyConfig> >();
            var overlayConfigProvider = Container.Resolve <IConfigProvider <MicSwitchOverlayConfig> >();
            var mainConfigProvider    = Container.Resolve <IConfigProvider <MicSwitchConfig> >();

            ActualizeConfig(mainConfigProvider, hotkeyConfigProvider);
            ActualizeConfig(mainConfigProvider, overlayConfigProvider);
            ActualizeConfig(mainConfigProvider);

            sw.Step("Registering overlay");
            var overlayController       = Container.Resolve <IOverlayWindowController>(WellKnownWindows.AllWindows);
            var overlayViewModelFactory = Container.Resolve <IFactory <IMicSwitchOverlayViewModel, IOverlayWindowController> >();
            var overlayViewModel        = overlayViewModelFactory.Create(overlayController).AddTo(Anchors);

            var mainWindow = Container.Resolve <MainWindow.Views.MainWindow>();

            Current.MainWindow = mainWindow;
            sw.Step($"Main window view initialized");

            var viewController      = new WindowViewController(mainWindow);
            var mainWindowViewModel = Container.Resolve <IMainWindowViewModel>(
                new DependencyOverride <IWindowViewController>(viewController),
                new DependencyOverride <IOverlayWindowController>(overlayController)).AddTo(Anchors);

            sw.Step($"Main window view model resolved");
            mainWindow.DataContext = mainWindowViewModel;
            sw.Step($"Main window view model assigned");
            mainWindow.Show();
            sw.Step($"Main window shown");
        }
示例#4
0
        public async UniTask Initialize()
        {
            // Clear
            Clear();

            foreach (var type in new[]
                     { typeof(Text), typeof(Sprite), typeof(Line), typeof(Video), typeof(Controller), typeof(NoteController) })
            {
                TypedComponentRenderers[type] = new List <StoryboardComponentRenderer>();
            }

            var timer = new BenchmarkTimer("StoryboardRenderer initialization");

            bool Predicate <TO>(TO obj) where TO : Object => !obj.IsManuallySpawned(); await SpawnObjects <NoteController, NoteControllerState, NoteControllerRenderer>(Storyboard.NoteControllers.Values.ToList(), noteController => new NoteControllerRenderer(this, noteController), Predicate);

            timer.Time("NoteController"); // Spawn note placeholder transforms
            await SpawnObjects <Text, TextState, TextRenderer>(Storyboard.Texts.Values.ToList(), text => new TextRenderer(this, text), Predicate);

            timer.Time("Text");
            await SpawnObjects <Sprite, SpriteState, SpriteRenderer>(Storyboard.Sprites.Values.ToList(), sprite => new SpriteRenderer(this, sprite), Predicate);

            timer.Time("Sprite");
            await SpawnObjects <Line, LineState, LineRenderer>(Storyboard.Lines.Values.ToList(), line => new LineRenderer(this, line), Predicate);

            timer.Time("Line");
            await SpawnObjects <Video, VideoState, VideoRenderer>(Storyboard.Videos.Values.ToList(), line => new VideoRenderer(this, line), Predicate);

            timer.Time("Video");
            await SpawnObjects <Controller, ControllerState, ControllerRenderer>(Storyboard.Controllers.Values.ToList(), controller => new ControllerRenderer(this, controller), Predicate);

            timer.Time("Controller");
            timer.Time();

            // Clear on abort/retry/complete
            Game.onGameDisposed.AddListener(_ =>
            {
                Dispose();
            });
            Game.onGamePaused.AddListener(_ =>
            {
                // TODO: Pause SB
            });
            Game.onGameWillUnpause.AddListener(_ =>
            {
                // TODO: Unpause SB
            });
        }
示例#5
0
        static public void Main(string[] args)
        {
            ConfirmQuickSyncReadiness.HaltIfNotReady();

            Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
            // keep ascending directories until 'media' folder is found
            for (int i = 0; i < 10 && !Directory.Exists("Media"); i++)
            {
                Directory.SetCurrentDirectory("..");
            }
            Directory.SetCurrentDirectory("Media");

            mfxIMPL impl            = mfxIMPL.MFX_IMPL_AUTO;
            CodecId inputCodecId    = CodecId.MFX_CODEC_JPEG;
            CodecId outputCodecId   = CodecId.MFX_CODEC_JPEG;
            string  outputExtension = ".transcoded.264";//this should match codecld above


            string inFilename;

            inFilename = @"C:\x\core-imaging-playground\images\IMG_2301.jpg";
            //  inFilename = "BigBuckBunny_320x180.264";
            //inFilename = "BigBuckBunny_1920x1080.264";
            //inFilename = "BigBuckBunny_3840x2160.264";
            string outFilename = Path.ChangeExtension(inFilename, outputExtension);

            Console.WriteLine("Working directory: {0}", Environment.CurrentDirectory);
            Console.WriteLine("Input filename: {0}", inFilename);
            Console.WriteLine();

            if (!File.Exists(inFilename))
            {
                Console.WriteLine("Input file not found. Press any key to exit.");
                Console.ReadKey();
                return;
            }


            Stream         infs, outfs;
            BenchmarkTimer bt = null;


#if !ENABLE_BENCHMARK
            infs  = File.Open(inFilename, FileMode.Open);
            outfs = File.Open(outFilename, FileMode.Create);
#else       // delete this code for most simple example
            // * Benchmark Mode *
            // this block does a couple things:
            //   1. causes the file to be pre-read into memory so we are not timing disk reads.
            //   2. replaces the output stream with a NullStream so nothing gets written to disk.
            //   3. Starts the timer for benchmarking
            // this pre-reads file into memory for benchmarking
            // maximumMemoryToAllocate = (long)4L * 1024 * 1024 * 1024;
            Console.WriteLine("Pre-reading input");
            infs = new PreReadLargeMemoryStream(File.Open(inFilename, FileMode.Open));
            Console.WriteLine("Input read");

            outfs = new NullStream();
            bt    = new BenchmarkTimer();
            bt.Start();

            //int minimumFrames = 4000;
#endif

            Console.WriteLine("Output filename: {0}",
                              Path.GetFileName((outfs as FileStream)?.Name ?? "NO OUTPUT"));
            Console.WriteLine();


            var config = TranscoderConfiguration.BuildTranscoderConfigurationFromStream(infs,
                                                                                        inputCodecId,
                                                                                        outputCodecId);

            var transcoder = new StreamTranscoder(infs, config, impl, false);

            string impltext = QuickSyncStatic.ImplementationString(transcoder.lowLevelTranscoder.session);
            Console.WriteLine("Implementation = {0}", impltext);
            //string memtext = QuickSyncStatic.ImplementationString(transcoder.lowLevelTranscoder.deviceSetup.memType);
            //Console.WriteLine("Memory type = {0}", memtext);



            int modulo = 100;

            int count = 0;


            foreach (var item in transcoder.GetFrames())
            {
                outfs.Write(item.bitstream, 0, item.bytesAvailable);

                if (++count % modulo == 0)
                {
                    Console.Write("Frames transcoded {0}\r", count);
                }
            }


            Console.WriteLine("Frames transcoded {0}", count);
            Console.WriteLine();

            if (bt != null)
            {
                bt.StopAndReport(count, infs.Position, outfs.Position);
            }

            infs.Close();
            outfs.Close();



            if (Debugger.IsAttached)
            {
                Console.WriteLine("done - press a key to exit");
                Console.ReadKey();
            }
        }
示例#6
0
        static void Main(string[] args)
        {
            ConfirmQuickSyncReadiness.HaltIfNotReady();

            Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
            // keep ascending directories until 'media' folder is found
            for (int i = 0; i < 10 && !Directory.Exists("Media"); i++)
            {
                Directory.SetCurrentDirectory("..");
            }
            Directory.SetCurrentDirectory("Media");


            int     width, height;
            string  inFilename;
            mfxIMPL impl   = mfxIMPL.MFX_IMPL_AUTO;
            FourCC  fourcc = FourCC.NV12;   // supported: RGB3 RGB4 BGR4 BGR3 NV12 I420 IYUV YUY2 UYVY YV12 P411 P422

            inFilename = "BigBuckBunny_320x180." + fourcc + ".yuv"; width = 320; height = 180;
            //inFilename = "BigBuckBunny_1920x1080." + fourcc + ".yuv"; width = 1920; height = 1080;


            string outFilename = Path.ChangeExtension(inFilename, "enc.264");


            Console.WriteLine("Working directory: {0}", Environment.CurrentDirectory);
            Console.WriteLine("Input filename: {0}", inFilename);
            Console.WriteLine("Input width: {0}  Input height: {1}", width, height);
            Console.WriteLine();

            if (!File.Exists(inFilename))
            {
                Console.WriteLine("Input file not found.");
                Console.WriteLine("Please let Decoder1 run to completion to create input file");
                Console.WriteLine("Press any key to exit.");
                Console.ReadKey();
                return;
            }


            Stream         infs, outfs;
            BenchmarkTimer bt = null;


#if !ENABLE_BENCHMARK
            infs  = File.Open(inFilename, FileMode.Open);
            outfs = File.Open(outFilename, FileMode.Create);
#else       // delete this code for most simple example
            // * Benchmark Mode *
            // this block does a couple things:
            //   1. causes the file to be pre-read into memory so we are not timing disk reads.
            //   2. replaces the output stream with a NullStream so nothing gets written to disk.
            //   3. Starts the timer for benchmarking
            // this pre-reads file into memory for benchmarking
            long maximumMemoryToAllocate = (long)4L * 1024 * 1024 * 1024;
            Console.WriteLine("Pre-reading input");
            infs = new PreReadLargeMemoryStream(File.Open(inFilename, FileMode.Open), maximumMemoryToAllocate);
            Console.WriteLine("Input read");

            outfs = new NullStream();
            bt    = new BenchmarkTimer();
            bt.Start();

            int minimumFrames = 4000;
#endif
            Console.WriteLine("Output filename: {0}",
                              Path.GetFileName((outfs as FileStream)?.Name ?? "NO OUTPUT"));
            Console.WriteLine();


            mfxVideoParam mfxEncParams = new mfxVideoParam();
            mfxEncParams.mfx.CodecId                 = CodecId.MFX_CODEC_AVC;
            mfxEncParams.mfx.TargetUsage             = TargetUsage.MFX_TARGETUSAGE_BALANCED;
            mfxEncParams.mfx.TargetKbps              = 2000;
            mfxEncParams.mfx.RateControlMethod       = RateControlMethod.MFX_RATECONTROL_VBR;
            mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
            mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
            mfxEncParams.mfx.FrameInfo.FourCC        = FourCC.NV12;
            mfxEncParams.mfx.FrameInfo.ChromaFormat  = ChromaFormat.MFX_CHROMAFORMAT_YUV420;
            mfxEncParams.mfx.FrameInfo.PicStruct     = PicStruct.MFX_PICSTRUCT_PROGRESSIVE;
            mfxEncParams.mfx.FrameInfo.CropX         = 0;
            mfxEncParams.mfx.FrameInfo.CropY         = 0;
            mfxEncParams.mfx.FrameInfo.CropW         = (ushort)width;
            mfxEncParams.mfx.FrameInfo.CropH         = (ushort)height;
            // Width must be a multiple of 16
            // Height must be a multiple of 16 in case of frame picture and a multiple of 32 in case of field picture
            mfxEncParams.mfx.FrameInfo.Width  = QuickSyncStatic.ALIGN16(width);
            mfxEncParams.mfx.FrameInfo.Height = QuickSyncStatic.AlignHeightTo32or16(height, mfxEncParams.mfx.FrameInfo.PicStruct);
            mfxEncParams.IOPattern            = IOPattern.MFX_IOPATTERN_IN_SYSTEM_MEMORY; // must be 'in system memory'
            mfxEncParams.AsyncDepth           = 4;                                        // Pipeline depth. Best at 4


            BitStreamChunk bsc = new BitStreamChunk(); //where we receive compressed frame data

            //var encoder = new LowLevelEncoder2(mfxEncParams, impl);
            ILowLevelEncoder encoder = new LowLevelEncoder(mfxEncParams, impl);


            string impltext = QuickSyncStatic.ImplementationString(encoder.session);
            Console.WriteLine("Implementation = {0}", impltext);
            //string memtext = QuickSyncStatic.ImplementationString(encoder.deviceSetup.memType);
            //Console.WriteLine("Memory type = {0}", memtext);

            var formatConverter = new NV12FromXXXXConverter(fourcc, width, height);


            int inputFrameLength = width * height * VideoUtility.GetBitsPerPixel(fourcc) / 8;

            byte[] uncompressed = new byte[inputFrameLength];

            int count = 0;

            while (infs.Read(uncompressed, 0, inputFrameLength) == inputFrameLength)
            {
                int ix = encoder.GetFreeFrameIndex();  //get index of free surface

                formatConverter.ConvertToNV12FrameSurface(ref encoder.Frames[ix], uncompressed, 0);

                encoder.EncodeFrame(ix, ref bsc);

                if (bsc.bytesAvailable > 0)
                {
                    outfs.Write(bsc.bitstream, 0, bsc.bytesAvailable);

                    if (++count % 100 == 0)
                    {
                        Console.Write("Frame {0}\r", count);
                    }
                }

#if ENABLE_BENCHMARK     // delete this code for most simple example
                if (infs.Position + inputFrameLength - 1 >= infs.Length)
                {
                    infs.Position = 0;
                }
                if (count >= minimumFrames)
                {
                    break;
                }
#endif
            }



            while (encoder.Flush(ref bsc))
            {
                if (bsc.bytesAvailable > 0)
                {
                    outfs.Write(bsc.bitstream, 0, bsc.bytesAvailable);

                    if (++count % 100 == 0)
                    {
                        Console.Write("Frame {0}\r", count);
                    }
                }
            }

            if (bt != null)
            {
                bt.StopAndReport(count, infs.Position, outfs.Position);
            }

            infs.Close();
            outfs.Close();

            encoder.Dispose();

            Console.WriteLine("Encoded {0} frames", count);

            if (Debugger.IsAttached)
            {
                Console.WriteLine("done - press a key to exit");
                Console.ReadKey();
            }
        }
示例#7
0
    public static IEnumerator StartServer(bool doLoad, string saveFileOverride, bool allowOutOfDateSaves)
    {
        float timeScale = UnityEngine.Time.timeScale;

        if (ConVar.Time.pausewhileloading)
        {
            UnityEngine.Time.timeScale = 0f;
        }
        RCon.Initialize();
        BaseEntity.Query.Server = new BaseEntity.Query.EntityTree(8096f);
        if ((bool)SingletonComponent <WorldSetup> .Instance)
        {
            yield return(SingletonComponent <WorldSetup> .Instance.StartCoroutine(SingletonComponent <WorldSetup> .Instance.InitCoroutine()));
        }
        if ((bool)SingletonComponent <DynamicNavMesh> .Instance && SingletonComponent <DynamicNavMesh> .Instance.enabled && !AiManager.nav_disable)
        {
            yield return(SingletonComponent <DynamicNavMesh> .Instance.StartCoroutine(SingletonComponent <DynamicNavMesh> .Instance.UpdateNavMeshAndWait()));
        }
        if ((bool)SingletonComponent <AiManager> .Instance && SingletonComponent <AiManager> .Instance.enabled)
        {
            SingletonComponent <AiManager> .Instance.Initialize();

            if (!AiManager.nav_disable && AI.npc_enable && TerrainMeta.Path != null)
            {
                foreach (MonumentInfo monument in TerrainMeta.Path.Monuments)
                {
                    if (monument.HasNavmesh)
                    {
                        yield return(monument.StartCoroutine(monument.GetMonumentNavMesh().UpdateNavMeshAndWait()));
                    }
                }
                if ((bool)TerrainMeta.Path && (bool)TerrainMeta.Path.DungeonRoot)
                {
                    DungeonNavmesh dungeonNavmesh = TerrainMeta.Path.DungeonRoot.AddComponent <DungeonNavmesh>();
                    dungeonNavmesh.NavMeshCollectGeometry = NavMeshCollectGeometry.PhysicsColliders;
                    dungeonNavmesh.LayerMask = 65537;
                    yield return(dungeonNavmesh.StartCoroutine(dungeonNavmesh.UpdateNavMeshAndWait()));
                }
                else
                {
                    Debug.LogError("Failed to find DungeonRoot, NOT generating Dungeon navmesh");
                }
            }
        }
        GameObject gameObject = GameManager.server.CreatePrefab("assets/bundled/prefabs/system/server.prefab");

        Object.DontDestroyOnLoad(gameObject);
        ServerMgr serverMgr = gameObject.GetComponent <ServerMgr>();

        serverMgr.Initialize(doLoad, saveFileOverride, allowOutOfDateSaves);
        yield return(CoroutineEx.waitForSecondsRealtime(0.1f));

        SaveRestore.InitializeEntityLinks();
        yield return(CoroutineEx.waitForSecondsRealtime(0.1f));

        SaveRestore.InitializeEntitySupports();
        yield return(CoroutineEx.waitForSecondsRealtime(0.1f));

        SaveRestore.InitializeEntityConditionals();
        yield return(CoroutineEx.waitForSecondsRealtime(0.1f));

        SaveRestore.GetSaveCache();
        yield return(CoroutineEx.waitForSecondsRealtime(0.1f));

        BaseGameMode.CreateGameMode();
        yield return(CoroutineEx.waitForSecondsRealtime(0.1f));

        serverMgr.OpenConnection();
        CompanionServer.Server.Initialize();
        using (BenchmarkTimer.New("Boombox.LoadStations"))
        {
            BoomBox.LoadStations();
        }
        if (ConVar.Time.pausewhileloading)
        {
            UnityEngine.Time.timeScale = timeScale;
        }
        WriteToLog("Server startup complete");
    }
示例#8
0
    private IEnumerator Start()
    {
        WriteToLog("Bootstrap Startup");
        BenchmarkTimer.Enabled = Facepunch.Utility.CommandLine.Full.Contains("+autobench");
        BenchmarkTimer timer = BenchmarkTimer.New("bootstrap");

        if (!UnityEngine.Application.isEditor)
        {
            ExceptionReporter.InitializeFromUrl("https://*****:*****@sentry.io/51080");
            ExceptionReporter.Disabled = !Facepunch.Utility.CommandLine.Full.Contains("-official") && !Facepunch.Utility.CommandLine.Full.Contains("-server.official") && !Facepunch.Utility.CommandLine.Full.Contains("+official") && !Facepunch.Utility.CommandLine.Full.Contains("+server.official");
            BuildInfo current = BuildInfo.Current;
            if (current.Scm.Branch != null && current.Scm.Branch.StartsWith("main"))
            {
                ExceptionReporter.InitializeFromUrl("https://*****:*****@sentry.io/1836389");
                ExceptionReporter.Disabled = false;
            }
        }
        if (AssetBundleBackend.Enabled)
        {
            AssetBundleBackend newBackend = new AssetBundleBackend();
            using (BenchmarkTimer.New("bootstrap;bundles"))
            {
                yield return(StartCoroutine(LoadingUpdate("Opening Bundles")));

                newBackend.Load("Bundles/Bundles");
                FileSystem.Backend = newBackend;
            }
            if (FileSystem.Backend.isError)
            {
                ThrowError(FileSystem.Backend.loadingError);
                yield break;
            }
            using (BenchmarkTimer.New("bootstrap;bundlesindex"))
            {
                newBackend.BuildFileIndex();
            }
        }
        if (FileSystem.Backend.isError)
        {
            ThrowError(FileSystem.Backend.loadingError);
            yield break;
        }
        if (!UnityEngine.Application.isEditor)
        {
            WriteToLog(SystemInfoGeneralText.currentInfo);
        }
        UnityEngine.Texture.SetGlobalAnisotropicFilteringLimits(1, 16);
        if (isErrored)
        {
            yield break;
        }
        using (BenchmarkTimer.New("bootstrap;gamemanifest"))
        {
            yield return(StartCoroutine(LoadingUpdate("Loading Game Manifest")));

            GameManifest.Load();
            yield return(StartCoroutine(LoadingUpdate("DONE!")));
        }
        using (BenchmarkTimer.New("bootstrap;selfcheck"))
        {
            yield return(StartCoroutine(LoadingUpdate("Running Self Check")));

            SelfCheck.Run();
        }
        if (isErrored)
        {
            yield break;
        }
        yield return(StartCoroutine(LoadingUpdate("Bootstrap Tier0")));

        using (BenchmarkTimer.New("bootstrap;tier0"))
        {
            Init_Tier0();
        }
        using (BenchmarkTimer.New("bootstrap;commandlinevalues"))
        {
            ConsoleSystem.UpdateValuesFromCommandLine();
        }
        yield return(StartCoroutine(LoadingUpdate("Bootstrap Systems")));

        using (BenchmarkTimer.New("bootstrap;init_systems"))
        {
            Init_Systems();
        }
        yield return(StartCoroutine(LoadingUpdate("Bootstrap Config")));

        using (BenchmarkTimer.New("bootstrap;init_config"))
        {
            Init_Config();
        }
        if (!isErrored)
        {
            yield return(StartCoroutine(LoadingUpdate("Loading Items")));

            using (BenchmarkTimer.New("bootstrap;itemmanager"))
            {
                ItemManager.Initialize();
            }
            if (!isErrored)
            {
                yield return(StartCoroutine(DedicatedServerStartup()));

                timer?.Dispose();
                GameManager.Destroy(base.gameObject);
            }
        }
    }
示例#9
0
    public async UniTask <List <Level> > LoadFromMetadataFiles(LevelType type, List <string> jsonPaths, bool forceReload = false)
    {
        var lowMemory = false;

        Application.lowMemory += OnLowMemory;
        void OnLowMemory()
        {
            lowMemory = true;
        }

        var loadedCount = 0;
        var tasks       = new List <UniTask>();
        var results     = new List <Level>();
        int index;

        for (index = 0; index < jsonPaths.Count; index++)
        {
            var loadIndex = index;
            async UniTask LoadLevel()
            {
                var timer = new BenchmarkTimer($"Level loader ({loadIndex + 1} / {jsonPaths.Count})")
                {
                    Enabled = false
                };
                var jsonPath = jsonPaths[loadIndex];

                try
                {
                    FileInfo info;
                    try
                    {
                        info = new FileInfo(jsonPath);
                        if (info.Directory == null)
                        {
                            throw new FileNotFoundException(info.ToString());
                        }
                    }
                    catch (Exception e)
                    {
                        Debug.LogWarning(e);
                        Debug.LogWarning($"{jsonPath} could not be read");
                        Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {jsonPath}");
                        return;
                    }

                    var path = info.Directory.FullName + Path.DirectorySeparatorChar;

                    if (!forceReload && loadedPaths.Contains(path))
                    {
                        Debug.LogWarning($"Level from {path} is already loaded");
                        Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {path}");
                        return;
                    }

                    Debug.Log($"Loading {loadIndex + 1}/{jsonPaths.Count} from {path}");

                    if (!File.Exists(jsonPath))
                    {
                        Debug.LogWarning($"level.json not found at {jsonPath}");
                        Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {path}");
                        return;
                    }

                    await UniTask.SwitchToThreadPool();

                    var meta = JsonConvert.DeserializeObject <LevelMeta>(File.ReadAllText(jsonPath));
                    await UniTask.SwitchToMainThread();

                    timer.Time("Deserialization");

                    if (meta == null)
                    {
                        Debug.LogWarning($"Invalid level.json at {jsonPath}");
                        Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {path}");
                        return;
                    }

                    if (type != LevelType.Temp && LoadedLocalLevels.ContainsKey(meta.id))
                    {
                        if (LoadedLocalLevels[meta.id].Type == LevelType.Tier && type == LevelType.User)
                        {
                            Debug.LogWarning($"Community level cannot override tier level");
                            Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {path}");
                            return;
                        }
                        if (LoadedLocalLevels[meta.id].Meta.version > meta.version)
                        {
                            Debug.LogWarning($"Level to load has smaller version than loaded level");
                            Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {path}");
                            return;
                        }
                        loadedPaths.Remove(LoadedLocalLevels[meta.id].Path);
                    }

                    // Sort charts
                    meta.SortCharts();

                    // Reject invalid level meta
                    if (!meta.Validate())
                    {
                        Debug.LogWarning($"Invalid metadata in level.json at {jsonPath}");
                        Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {path}");
                        return;
                    }

                    timer.Time("Validate");

                    var db = Context.Database;
                    await UniTask.SwitchToThreadPool();

                    var level  = Level.FromLocal(path, type, meta, db);
                    var record = level.Record;
                    if (record.AddedDate == DateTimeOffset.MinValue)
                    {
                        record.AddedDate = Context.Library.Levels.ContainsKey(level.Id)
                            ? Context.Library.Levels[level.Id].Date
                            : info.LastWriteTimeUtc;
                        level.SaveRecord();
                    }
                    await UniTask.SwitchToMainThread();

                    timer.Time("LevelRecord");

                    if (type != LevelType.Temp)
                    {
                        LoadedLocalLevels[meta.id] = level;
                        loadedPaths.Add(path);

                        // Generate thumbnail
                        if (!File.Exists(level.Path + CoverThumbnailFilename))
                        {
                            var thumbnailPath = "file://" + level.Path + level.Meta.background.path;

                            if (lowMemory)
                            {
                                // Give up
                                Debug.LogWarning($"Low memory!");
                                Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {jsonPath}");
                                return;
                            }

                            using (var request = UnityWebRequest.Get(thumbnailPath))
                            {
                                await request.SendWebRequest();

                                if (request.isNetworkError || request.isHttpError)
                                {
                                    Debug.LogWarning(request.error);
                                    Debug.LogWarning($"Cannot get background texture from {thumbnailPath}");
                                    Debug.LogWarning(
                                        $"Skipped generating thumbnail for {loadIndex + 1}/{jsonPaths.Count}: {meta.id} ({path})");
                                    return;
                                }

                                var coverTexture = request.downloadHandler.data.ToTexture2D();
                                if (coverTexture == null)
                                {
                                    Debug.LogWarning(request.error);
                                    Debug.LogWarning($"Cannot get background texture from {thumbnailPath}");
                                    Debug.LogWarning(
                                        $"Skipped generating thumbnail for {loadIndex + 1}/{jsonPaths.Count}: {meta.id} ({path})");
                                    return;
                                }

                                if (lowMemory)
                                {
                                    // Give up
                                    Object.Destroy(coverTexture);
                                    Debug.LogWarning($"Low memory!");
                                    Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {jsonPath}");
                                    return;
                                }

                                var croppedTexture = TextureScaler.FitCrop(coverTexture, Context.LevelThumbnailWidth,
                                                                           Context.LevelThumbnailHeight);

                                if (lowMemory)
                                {
                                    // Give up
                                    Object.Destroy(coverTexture);
                                    Object.Destroy(croppedTexture);
                                    Debug.LogWarning($"Low memory!");
                                    Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {jsonPath}");
                                    return;
                                }

                                var bytes = croppedTexture.EncodeToJPG();
                                Object.Destroy(coverTexture);
                                Object.Destroy(croppedTexture);

                                await UniTask.DelayFrame(0); // Reduce load to prevent crash

                                try
                                {
                                    File.WriteAllBytes(level.Path + CoverThumbnailFilename, bytes);
                                    Debug.Log(
                                        $"Thumbnail generated {loadIndex + 1}/{jsonPaths.Count}: {level.Id} ({thumbnailPath})");

                                    await UniTask.DelayFrame(0); // Reduce load to prevent crash
                                }
                                catch (Exception e)
                                {
                                    Debug.LogWarning(e);
                                    Debug.LogWarning($"Could not write to {level.Path + CoverThumbnailFilename}");
                                    Debug.LogWarning(
                                        $"Skipped generating thumbnail for {loadIndex + 1}/{jsonPaths.Count} from {jsonPath}");
                                }
                            }

                            timer.Time("Generate thumbnail");
                        }
                    }

                    results.Add(level);
                    OnLevelLoadProgress.Invoke(meta.id, ++loadedCount, jsonPaths.Count);
                    Debug.Log($"Loaded {loadIndex + 1}/{jsonPaths.Count}: {meta.id} ");
                    timer.Time("OnLevelLoadProgressEvent");
                }
                catch (Exception e)
                {
                    Debug.LogError(e);
                    Debug.LogError($"Unexpected error while loading from {jsonPath}");
                    Debug.LogWarning($"Skipped {loadIndex + 1}/{jsonPaths.Count} from {jsonPath}");
                }

                timer.Time();
            }

            tasks.Add(LoadLevel());
        }

        await UniTask.WhenAll(tasks);

        Application.lowMemory -= OnLowMemory;
        return(results);
    }
示例#10
0
        public EyeOverlayViewModel(
            [NotNull] [Dependency(WellKnownWindows.AllWindows)] IWindowTracker mainWindowTracker,
            [NotNull] IOverlayWindowController overlayWindowController,
            [NotNull] IAuraModelController auraModelController,
            [NotNull] IWindowListProvider windowListProvider,
            [NotNull] ISelectionAdornerViewModel selectionAdorner,
            [NotNull] [Dependency(WellKnownSchedulers.UI)] IScheduler uiScheduler)
        {
            using var sw = new BenchmarkTimer("Initialization", Log, nameof(EyeOverlayViewModel));
            SelectionAdorner = selectionAdorner.AddTo(Anchors);
            activeConfigEditorAnchors.AddTo(Anchors);
            this.mainWindowTracker = mainWindowTracker;
            this.overlayWindowController = overlayWindowController;
            this.auraModelController = auraModelController;
            this.windowListProvider = windowListProvider;
            MinSize = new Size(32, 32);
            SizeToContent = SizeToContent.Manual;
            Width = 400;
            Height = 400;
            Left = 200;
            Top = 200;
            IsUnlockable = true;
            Title = "EyeAuras";
            EnableHeader = false;
            thumbnailOpacity.SetDefaultValue(DefaultThumbnailOpacity);

            ResetRegionCommandExecuted();
            sw.Step("Basic properties initialized");
            
            WhenLoaded
                .Take(1)
                .Subscribe(ApplyConfig)
                .AddTo(Anchors);
            sw.Step("WhenLoaded executed");
            
            resetRegionCommand = CommandWrapper.Create(ResetRegionCommandExecuted, ResetRegionCommandCanExecute);
            selectRegionCommand = CommandWrapper.Create(SelectRegionCommandExecuted, SelectRegionCommandCanExecute);
            closeConfigEditorCommand = CommandWrapper.Create(CloseConfigEditorCommandExecuted);
            fitOverlayCommand = CommandWrapper.Create<double?>(FitOverlayCommandExecuted);
            setAttachedWindowCommand = CommandWrapper.Create<WindowHandle>(SetAttachedWindowCommandExecuted);
            setClickThroughCommand = CommandWrapper.Create<bool?>(SetClickThroughModeExecuted);
            DisableAuraCommand = CommandWrapper.Create(() => auraModelController.IsEnabled = false);
            CloseCommand = CommandWrapper.Create(CloseCommandExecuted, auraModelController.WhenAnyValue(x => x.CloseController).Select(CloseCommandCanExecute));
            ToggleLockStateCommand = CommandWrapper.Create(
                () =>
                {
                    if (IsLocked && UnlockWindowCommand.CanExecute(null))
                    {
                        UnlockWindowCommand.Execute(null);
                    }
                    else if (!IsLocked && LockWindowCommand.CanExecute(null))
                    {
                        LockWindowCommand.Execute(null);
                    }
                    else
                    {
                        throw new ApplicationException($"Something went wrong - invalid Overlay Lock state: {new {IsLocked, IsUnlockable, CanUnlock = UnlockWindowCommand.CanExecute(null), CanLock = LockWindowCommand.CanExecute(null)  }}");
                    }
                });

            auraModelController.WhenAnyValue(x => x.Name)
                .Where(x => !string.IsNullOrEmpty(x))
                .Subscribe(x => OverlayName = x)
                .AddTo(Anchors);

            this.RaiseWhenSourceValue(x => x.ActiveThumbnailOpacity, thumbnailOpacity, x => x.Value).AddTo(Anchors);
            this.RaiseWhenSourceValue(x => x.ThumbnailOpacity, this, x => x.ActiveThumbnailOpacity).AddTo(Anchors);
            this.RaiseWhenSourceValue(x => x.SourceBounds, Region, x => x.Bounds).AddTo(Anchors);

            isInEditMode = Observable.Merge(
                    this.WhenAnyProperty(x => x.IsInSelectMode, x => x.IsLocked))
                .Select(change => IsInSelectMode || !IsLocked)
                .ToPropertyHelper(this, x => x.IsInEditMode, uiScheduler)
                .AddTo(Anchors);

            this.WhenAnyValue(x => x.IsLocked)
                .Where(x => x && isInSelectMode)
                .Subscribe(() => IsInSelectMode = false)
                .AddTo(Anchors);

            aspectRatio = this.WhenAnyProperty(x => x.Bounds, x => x.ViewModelLocation)
                .Select(change => Width >= 0 && Height >= 0
                    ? Width / Height
                    : double.PositiveInfinity)
                .ToPropertyHelper(this, x => x.AspectRatio, uiScheduler)
                .AddTo(Anchors);
            sw.ResetStep();
            configEditorSupplier = new Lazy<OverlayConfigEditor>(() => CreateConfigEditor(this));
            sw.Step("Initialized Config editor");
        }
示例#11
0
        public OverlayAuraModelBase(
            [NotNull] ISharedContext sharedContext,
            [NotNull] IAuraRepository repository,
            [NotNull] IConfigSerializer configSerializer,
            [NotNull] IUniqueIdGenerator idGenerator,
            [NotNull] IFactory <IEyeOverlayViewModel, IOverlayWindowController, IAuraModelController> overlayViewModelFactory,
            [NotNull] IFactory <IOverlayWindowController, IWindowTracker> overlayWindowControllerFactory,
            [NotNull] IFactory <WindowTracker, IStringMatcher> windowTrackerFactory,
            [NotNull][Dependency(WellKnownSchedulers.UI)] IScheduler uiScheduler,
            [NotNull][Dependency(WellKnownSchedulers.Background)] IScheduler bgScheduler)
        {
            defaultAuraName = $"Aura #{Interlocked.Increment(ref GlobalAuraIdx)}";
            Name            = defaultAuraName;
            Id           = idGenerator.Next();
            using var sw = new BenchmarkTimer($"[{Name}({Id})] OverlayAuraModel initialization", Log, nameof(OverlayAuraModelBase));

            var auraTriggers = new ComplexAuraTrigger();

            Triggers = auraTriggers.Triggers;

            var auraActions = new ComplexAuraAction();

            OnEnterActions = auraActions.Actions;

            this.repository       = repository;
            this.configSerializer = configSerializer;
            var matcher       = new RegexStringMatcher().AddToWhitelist(".*");
            var windowTracker = windowTrackerFactory
                                .Create(matcher)
                                .AddTo(Anchors);

            var overlayController = overlayWindowControllerFactory
                                    .Create(windowTracker)
                                    .AddTo(Anchors);

            sw.Step($"Overlay controller created: {overlayController}");

            var overlayViewModel = overlayViewModelFactory
                                   .Create(overlayController, this)
                                   .AddTo(Anchors);

            sw.Step($"Overlay view model created: {overlayViewModel}");

            Overlay = overlayViewModel;
            Observable.Merge(
                overlayViewModel.WhenValueChanged(x => x.AttachedWindow, false).ToUnit(),
                overlayViewModel.WhenValueChanged(x => x.IsLocked, false).ToUnit(),
                this.WhenValueChanged(x => x.IsActive, false).ToUnit())
            .StartWithDefault()
            .Select(
                () => new
            {
                OverlayShouldBeShown = IsActive || !overlayViewModel.IsLocked,
                WindowIsAttached     = overlayViewModel.AttachedWindow != null
            })
            .Subscribe(x => overlayController.IsEnabled = x.OverlayShouldBeShown && x.WindowIsAttached)
            .AddTo(Anchors);
            sw.Step($"Overlay view model initialized: {overlayViewModel}");

            Observable.CombineLatest(
                auraTriggers.WhenAnyValue(x => x.IsActive),
                sharedContext.SystemTrigger.WhenValueChanged(x => x.IsActive))
            .DistinctUntilChanged()
            .Subscribe(x => IsActive = x.All(isActive => isActive), Log.HandleException)
            .AddTo(Anchors);

            auraTriggers.WhenAnyValue(x => x.IsActive)
            .WithPrevious((prev, curr) => new { prev, curr })
            .Where(x => x.prev == false && x.curr)
            .Subscribe(ExecuteOnEnterActions, Log.HandleException)
            .AddTo(Anchors);

            this.repository.KnownEntities
            .ToObservableChangeSet()
            .SkipInitial()
            .Throttle(ModelsReloadTimeout, bgScheduler)
            .ObserveOn(uiScheduler)
            .Subscribe(
                () =>
            {
                var properties = Properties;
                ReloadCollections(properties);
            })
            .AddTo(Anchors);

            var modelPropertiesToIgnore = new[]
            {
                nameof(IAuraTrigger.IsActive),
                nameof(IAuraTrigger.TriggerDescription),
                nameof(IAuraTrigger.TriggerName),
            }.ToImmutableHashSet();

            //FIXME Properties mechanism should have inverted logic - only important parameters must matter
            Observable.Merge(
                this.WhenAnyProperty(x => x.Name, x => x.TargetWindow, x => x.IsEnabled).Select(x => $"[{Name}].{x.EventArgs.PropertyName} property changed"),
                Overlay.WhenAnyProperty().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{nameof(Overlay)}.{x.EventArgs.PropertyName} property changed"),
                Triggers.ToObservableChangeSet().Select(x => $"[{Name}({Id})] Trigger list changed, item count: {Triggers.Count}"),
                Triggers.ToObservableChangeSet().WhenPropertyChanged().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{x.Sender}.{x.EventArgs.PropertyName} Trigger property changed"),
                OnEnterActions.ToObservableChangeSet().Select(x => $"[{Name}({Id})] Action list changed, item count: {OnEnterActions.Count}"),
                OnEnterActions.ToObservableChangeSet().WhenPropertyChanged().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{x.Sender}.{x.EventArgs.PropertyName} Action property changed"))
            .Subscribe(reason => RaisePropertyChanged(nameof(Properties)))
            .AddTo(Anchors);

            Disposable.Create(() =>
            {
                Log.Debug(
                    $"Disposed Aura {Name}({Id}) (aka {defaultAuraName}), triggers: {Triggers.Count}, actions: {OnEnterActions.Count}");
                OnEnterActions.Clear();
                Triggers.Clear();
            }).AddTo(Anchors);
            sw.Step($"Overlay model properties initialized");

            overlayController.RegisterChild(overlayViewModel).AddTo(Anchors);
            sw.Step($"Overlay registration completed: {this}");
        }
示例#12
0
        public void Parse()
        {
            if ((bool?)RootObject["compiled"] == true)
            {
                // Directly load into memory
                ((JArray)RootObject["texts"]).Select(it => it.ToObject <Text>()).ForEach(it => Texts[it.Id]                   = it);
                ((JArray)RootObject["sprites"]).Select(it => it.ToObject <Sprite>()).ForEach(it => Sprites[it.Id]             = it);
                ((JArray)RootObject["videos"]).Select(it => it.ToObject <Video>()).ForEach(it => Videos[it.Id]                = it);
                ((JArray)RootObject["lines"]).Select(it => it.ToObject <Line>()).ForEach(it => Lines[it.Id]                   = it);
                ((JArray)RootObject["controllers"]).Select(it => it.ToObject <Controller>()).ForEach(it => Controllers[it.Id] = it);
                ((JArray)RootObject["note_controllers"]).Select(it => it.ToObject <NoteController>()).ForEach(it => NoteControllers[it.Id] = it);
            }
            else
            {
                // Parse

                // Templates
                if (RootObject["templates"] != null)
                {
                    foreach (var templateProperty in RootObject["templates"].Children <JProperty>())
                    {
                        Templates[templateProperty.Name] = templateProperty.Value.ToObject <JObject>();
                    }
                }

                void ParseStateObjects <TO, TS>(string rootTokenName, Dictionary <string, TO> addToDictionary,
                                                Action <JObject> tokenPreprocessor = null)
                    where TO : Object <TS>, new() where TS : ObjectState, new()
                {
                    if (RootObject[rootTokenName] == null)
                    {
                        return;
                    }
                    foreach (var childToken in (JArray)RootObject[rootTokenName])
                    {
                        foreach (var objectToken in PopulateJObjects((JObject)childToken))
                        {
                            tokenPreprocessor?.Invoke(objectToken);
                            var obj = LoadObject <TO, TS>(objectToken);
                            if (obj != null)
                            {
                                if (addToDictionary.ContainsKey(obj.Id))
                                {
                                    Debug.LogError($"Storyboard: Redefinition of element {obj.Id}");
                                    continue;
                                }
                                addToDictionary[obj.Id] = obj;
                            }
                        }
                    }
                }

                var timer = new BenchmarkTimer("Storyboard parsing");
                ParseStateObjects <Text, TextState>("texts", Texts);
                timer.Time("Text");
                ParseStateObjects <Sprite, SpriteState>("sprites", Sprites);
                timer.Time("Sprite");
                ParseStateObjects <Video, VideoState>("videos", Videos);
                timer.Time("Videos");
                ParseStateObjects <Line, LineState>("lines", Lines);
                timer.Time("Lines");
                ParseStateObjects <NoteController, NoteControllerState>("note_controllers", NoteControllers, token =>
                {
                    // Note controllers have time default to zero
                    if (token["time"] == null)
                    {
                        token["time"] = 0;
                    }
                });
                timer.Time("NoteController");
                ParseStateObjects <Controller, ControllerState>("controllers", Controllers, token =>
                {
                    // Controllers have time default to zero
                    if (token["time"] == null)
                    {
                        token["time"] = 0;
                    }
                });
                timer.Time("Controller");
                timer.Time();

                // Trigger
                if (RootObject["triggers"] != null)
                {
                    foreach (var objectToken in (JArray)RootObject["triggers"])
                    {
                        Triggers.Add(LoadTrigger(objectToken));
                    }
                }
            }
        }
示例#13
0
    public void Initialize()
    {
        initialDragLineObjectCount = initialNoteObjectCount[NoteType.DragHead]
                                     + initialNoteObjectCount[NoteType.DragChild]
                                     + initialNoteObjectCount[NoteType.CDragHead]
                                     + initialNoteObjectCount[NoteType.CDragChild];
        var timer = new BenchmarkTimer("Game ObjectPool");

        foreach (var type in initialNoteObjectCount.Keys)
        {
            for (var i = 0; i < initialNoteObjectCount[type]; i++)
            {
                Collect(notePoolItems[type], Instantiate(notePoolItems[type], new NoteInstantiateProvider {
                    Type = type
                }));
            }
        }
        timer.Time("Notes");
        for (var i = 0; i < initialDragLineObjectCount; i++)
        {
            Collect(dragLinePoolItem, Instantiate(dragLinePoolItem, new PoolItemInstantiateProvider()));
        }
        timer.Time("DragLines");
        var chart = Game.Chart;
        var map   = new Dictionary <EffectController.Effect, int>
        {
            {
                EffectController.Effect.Clear,
                chart.MaxSamePageNonDragTypeNoteCount * 2
            },
            {
                EffectController.Effect.ClearDrag,
                chart.MaxSamePageDragTypeNoteCount * 2
            },
            {
                EffectController.Effect.Miss,
                chart.MaxSamePageNoteCount * 2
            },
            {
                EffectController.Effect.Hold,
                chart.MaxSamePageHoldTypeNoteCount * 16 * 2
            }
        };

        foreach (var pair in map)
        {
            var effect = pair.Key;
            var count  = pair.Value;
            Debug.Log($"{effect} => {count}");
            for (var i = 0; i < count; i++)
            {
                Collect(effectPoolItems[effect], Instantiate(
                            effectPoolItems[effect], new ParticleSystemInstantiateProvider
                {
                    Prefab = Game.effectController.GetPrefab(effect),
                    Parent = Game.effectController.EffectParentTransform
                }));
            }
        }
        timer.Time("Effects");
        timer.Time();
    }
示例#14
0
        static public void Main()
        {
            ConfirmQuickSyncReadiness.HaltIfNotReady();

            Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
            // keep ascending directories until 'media' folder is found
            for (int i = 0; i < 10 && !Directory.Exists("Media"); i++)
            {
                Directory.SetCurrentDirectory("..");
            }
            Directory.SetCurrentDirectory("Media");

            mfxIMPL impl    = mfxIMPL.MFX_IMPL_AUTO; //automatic GPU/CPU mode
            CodecId codecId = CodecId.MFX_CODEC_AVC;
            // avc fourcc supported: RGB3 RGB4 BGR4 BGR3 NV12 I420 IYUV YUY2 UYVY YV12 P411 P422
            FourCC fourcc       = FourCC.NV12;
            string fourccString = fourcc.ToString().Substring(0, 4);

            string inFilename;

            inFilename = "BigBuckBunny_320x180.264";
            //inFilename = "BigBuckBunny_1920x1080.264";
            //inFilename = "BigBuckBunny_3840x2160.264";
            string outFilename = Path.ChangeExtension(inFilename, fourccString + ".yuv");

            Console.WriteLine("Working directory: {0}", Environment.CurrentDirectory);
            Console.WriteLine("Input filename: {0}", inFilename);
            Console.WriteLine();

            if (!File.Exists(inFilename))
            {
                Console.WriteLine("Input file not found. Press any key to exit.");
                Console.ReadKey();
                return;
            }


            Stream         infs, outfs;
            BenchmarkTimer bt = null;


#if !ENABLE_BENCHMARK
            infs  = File.Open(inFilename, FileMode.Open);
            outfs = File.Open(outFilename, FileMode.Create);
#else       // delete this code for most simple example
            // * Benchmark Mode *
            // this block does a couple things:
            //   1. causes the file to be pre-read into memory so we are not timing disk reads.
            //   2. replaces the output stream with a NullStream so nothing gets written to disk.
            //   3. Starts the timer for benchmarking
            // this pre-reads file into memory for benchmarking
            // maximumMemoryToAllocate = (long)4L * 1024 * 1024 * 1024;
            Console.WriteLine("Pre-reading input");
            infs = new PreReadLargeMemoryStream(File.Open(inFilename, FileMode.Open));
            Console.WriteLine("Input read");

            outfs = new NullStream();
            bt    = new BenchmarkTimer();
            bt.Start();

            //int minimumFrames = 4000;
#endif

            Console.WriteLine("Output filename: {0}",
                              Path.GetFileName((outfs as FileStream)?.Name ?? "NO OUTPUT"));
            Console.WriteLine();

            var outIOPattern = IOPattern.MFX_IOPATTERN_OUT_SYSTEM_MEMORY;

            mfxVideoParam decoderParameters = QuickSyncStatic.ReadFileHeaderInfo(codecId, impl, infs, outIOPattern);
            decoderParameters.mfx.FrameInfo.FourCC = fourcc;

            var decoder = new StreamDecoder(infs, CodecId.MFX_CODEC_AVC, impl, outIOPattern);

            string impltext = QuickSyncStatic.ImplementationString(decoder.lowLevelDecoder.session);
            Console.WriteLine("Implementation = {0}", impltext);



            var formatConverter = new NV12ToXXXXConverter(fourcc, decoder.width, decoder.height);



            int count = 0;



            foreach (var frame in decoder.GetFrames())
            {
                var frameBytes = formatConverter.ConvertFromNV12(frame.Data);        // Convert to format requested
                outfs.Write(frameBytes, 0, frameBytes.Length);



                if (++count % 100 == 0)
                {
                    Console.Write("Frame {0}\r", count);
                }
            }
            Console.WriteLine("Decoded {0} frames", count);
            Console.WriteLine();

            if (bt != null)
            {
                bt.StopAndReport(count, infs.Position, outfs.Position);
            }

            infs.Close();
            outfs.Close();



            // make sure program always waits for user, except F5-Release run
            if (!UnitTest.IsRunning && Debugger.IsAttached ||
                Environment.GetEnvironmentVariable("VisualStudioVersion") == null)
            {
                Console.WriteLine("done - press a key to exit");
                Console.ReadKey();
            }
        }
示例#15
0
        unsafe static void Main(string[] args)
        {
            ConfirmQuickSyncReadiness.HaltIfNotReady();

            Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
            // keep ascending directories until 'media' folder is found
            for (int i = 0; i < 10 && !Directory.Exists("Media"); i++)
            {
                Directory.SetCurrentDirectory("..");
            }
            Directory.SetCurrentDirectory("Media");


            CodecId codecId = CodecId.MFX_CODEC_JPEG;
            FourCC  fourcc  = FourCC.UYVY;  // supported: RGB4, YUY2 NV12 [UYVY through tricks! see below]
            mfxIMPL impl    = mfxIMPL.MFX_IMPL_AUTO;


            int    width, height;
            string inFilename;

            //inFilename = "BigBuckBunny_320x180." + fourcc + ".yuv"; width = 320; height = 180;
            inFilename = "BigBuckBunny_1920x1080." + fourcc + ".yuv"; width = 1920; height = 1080;
            string outFilename = Path.ChangeExtension(inFilename, "enc.jpeg");


            Console.WriteLine("Working directory: {0}", Environment.CurrentDirectory);
            Console.WriteLine("Input filename: {0}", inFilename);
            Console.WriteLine("Input width: {0}  Input height: {1}", width, height);


            if (!File.Exists(inFilename))
            {
                Console.WriteLine("Input file not found.");
                Console.WriteLine("Please let Decoder1 run to completion to create input file");
                Console.WriteLine("Press any key to exit.");
                Console.ReadKey();
                return;
            }


            Stream         infs, outfs;
            BenchmarkTimer bt = null;


#if !ENABLE_BENCHMARK
            infs  = File.Open(inFilename, FileMode.Open);
            outfs = File.Open(outFilename, FileMode.Create);
#else       // delete this code for most simple example
            // * Benchmark Mode *
            // this block does a couple things:
            //   1. causes the file to be pre-read into memory so we are not timing disk reads.
            //   2. replaces the output stream with a NullStream so nothing gets written to disk.
            //   3. Starts the timer for benchmarking
            // this pre-reads file into memory for benchmarking
            long maximumMemoryToAllocate = (long)4L * 1024 * 1024 * 1024;
            Console.WriteLine("Pre-reading input");
            infs = new PreReadLargeMemoryStream(File.Open(inFilename, FileMode.Open), maximumMemoryToAllocate);
            Console.WriteLine("Input read");

            outfs = new NullStream();
            bt    = new BenchmarkTimer();
            bt.Start();

            int minimumFrames = 4000;
#endif

            Console.WriteLine("Output filename: {0}",
                              Path.GetFileName((outfs as FileStream)?.Name ?? "NO OUTPUT"));
            Console.WriteLine();

            // The encoder cannot encode UYVY, but if you are the only decoder of the JPEG
            // files, you can encode UYVY as YUY2 and everything is good.
            if (fourcc == FourCC.UYVY)
            {
                fourcc = FourCC.YUY2;
            }


            mfxVideoParam mfxEncParams = new mfxVideoParam();
            mfxEncParams.mfx.CodecId     = codecId;
            mfxEncParams.mfx.TargetUsage = TargetUsage.MFX_TARGETUSAGE_BALANCED;
            //mfxEncParams.mfx.TargetKbps = 2000;
            //mfxEncParams.mfx.RateControlMethod = RateControlMethod.MFX_RATECONTROL_VBR;
            mfxEncParams.mfx.Quality                 = 90;
            mfxEncParams.mfx.Interleaved             = 1;
            mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
            mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
            mfxEncParams.mfx.FrameInfo.FourCC        = fourcc;


            switch (fourcc)
            {
            case FourCC.NV12:
            case FourCC.YV12:
                mfxEncParams.mfx.FrameInfo.ChromaFormat = ChromaFormat.MFX_CHROMAFORMAT_YUV420;
                break;

            case FourCC.YUY2:
                mfxEncParams.mfx.FrameInfo.ChromaFormat = ChromaFormat.MFX_CHROMAFORMAT_YUV422V;     // fatal on SKYLAKE!
                mfxEncParams.mfx.FrameInfo.ChromaFormat = ChromaFormat.MFX_CHROMAFORMAT_YUV422;
                break;

            case FourCC.RGB4:
                mfxEncParams.mfx.FrameInfo.ChromaFormat = ChromaFormat.MFX_CHROMAFORMAT_YUV444;
                break;

            default:
                Trace.Assert(false);
                break;
            }


            mfxEncParams.mfx.FrameInfo.PicStruct = PicStruct.MFX_PICSTRUCT_PROGRESSIVE;
            mfxEncParams.mfx.FrameInfo.CropX     = 0;
            mfxEncParams.mfx.FrameInfo.CropY     = 0;
            mfxEncParams.mfx.FrameInfo.CropW     = (ushort)width;
            mfxEncParams.mfx.FrameInfo.CropH     = (ushort)height;
            // Width must be a multiple of 16
            // Height must be a multiple of 16 in case of frame picture and a multiple of 32 in case of field picture
            mfxEncParams.mfx.FrameInfo.Width  = QuickSyncStatic.ALIGN16(width);
            mfxEncParams.mfx.FrameInfo.Height = QuickSyncStatic.AlignHeightTo32or16(height, mfxEncParams.mfx.FrameInfo.PicStruct);
            mfxEncParams.IOPattern            = IOPattern.MFX_IOPATTERN_IN_SYSTEM_MEMORY; // must be 'in system memory'
            mfxEncParams.AsyncDepth           = 4;                                        // Pipeline depth. Best at 4


            mfxEncParams.mfx.FrameInfo.Width  = QuickSyncStatic.ALIGN32(width);
            mfxEncParams.mfx.FrameInfo.Height = QuickSyncStatic.ALIGN32(height);


            BitStreamChunk bsc = new BitStreamChunk(); //where we receive compressed frame data

            ILowLevelEncoder encoder = new LowLevelEncoder(mfxEncParams, impl);
            //ILowLevelEncoder encoder = new LowLevelEncoder(mfxEncParams, impl);


            string impltext = QuickSyncStatic.ImplementationString(encoder.session);
            Console.WriteLine("Implementation = {0}", impltext);


            // not needed for YUY2 encoding
            //var formatConverter = new NV12FromXXXXConverter(fileFourcc, width, height);


            int inputFrameLength = width * height * VideoUtility.GetBitsPerPixel(fourcc) / 8;

            byte[] uncompressed = new byte[inputFrameLength];

            int count = 0;

            // we do not call encoder.LockFrame() and encoder.UnlockFrame() as this example is
            // for system memory.


            while (infs.Read(uncompressed, 0, inputFrameLength) == inputFrameLength)
            {
                int ix = encoder.GetFreeFrameIndex();  //this call relys locks in authoritative array of surf

                //formatConverter.ConvertToNV12FrameSurface(ref encoder.Frames[ix], uncompressed, 0);
                mfxFrameSurface1 *f = (mfxFrameSurface1 *)encoder.Frames[ix];


                switch (fourcc)
                {
                case FourCC.NV12:
                    Trace.Assert(f->Data.Pitch == width * 1);

                    fixed(byte *aa = &uncompressed[0])
                    FastMemcpyMemmove.memcpy(f->Data.Y, (IntPtr)aa, height * width);

                    fixed(byte *aa = &uncompressed[height * width])
                    FastMemcpyMemmove.memcpy(f->Data.UV, (IntPtr)aa, height / 2 * width);

                    break;

                case FourCC.YUY2:

                    Trace.Assert(f->Data.Pitch == width * 2);

                    fixed(byte *aa = &uncompressed[0])
                    FastMemcpyMemmove.memcpy(f->Data.Y, (IntPtr)aa, height * width * 2);

                    break;

                default:
                    Trace.Assert(false);
                    break;
                }

                encoder.EncodeFrame(ix, ref bsc);

                if (bsc.bytesAvailable > 0)
                {
                    outfs.Write(bsc.bitstream, 0, bsc.bytesAvailable);

                    if (++count % 100 == 0)
                    {
                        Console.Write("Frame {0}\r", count);
                    }
                }

#if ENABLE_BENCHMARK     // delete this code for most simple example
                if (infs.Position + inputFrameLength - 1 >= infs.Length)
                {
                    infs.Position = 0;
                }
                if (count >= minimumFrames)
                {
                    break;
                }
#endif
            }

            while (encoder.Flush(ref bsc))
            {
                if (bsc.bytesAvailable > 0)
                {
                    outfs.Write(bsc.bitstream, 0, bsc.bytesAvailable);

                    if (++count % 100 == 0)
                    {
                        Console.Write("Frame {0}\r", count);
                    }
                }
            }

            if (bt != null)
            {
                bt.StopAndReport(count, infs.Position, outfs.Position);
            }

            infs.Close();
            outfs.Close();

            encoder.Dispose();

            Console.WriteLine("Encoded {0} frames", count);

            // make sure program always waits for user, except F5-Release run
            if (Debugger.IsAttached ||
                Environment.GetEnvironmentVariable("VisualStudioVersion") == null)
            {
                Console.WriteLine("done - press a key to exit");
                Console.ReadKey();
            }
        }
示例#16
0
        unsafe static void Main(string[] args)
        {
            ConfirmQuickSyncReadiness.HaltIfNotReady();

            Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
            // keep ascending directories until 'media' folder is found
            for (int i = 0; i < 10 && !Directory.Exists("Media"); i++)
            {
                Directory.SetCurrentDirectory("..");
            }
            Directory.SetCurrentDirectory("Media");


            CodecId codecId = CodecId.MFX_CODEC_JPEG;
            FourCC  fourcc  = FourCC.UYVY;  // supported: RGB4, YUY2 NV12 [UYVY through tricks! see below]
            mfxIMPL impl    = mfxIMPL.MFX_IMPL_AUTO;



            string fourccString = fourcc.ToString().Substring(0, 4);
            string inFilename;

            //inFilename = "BigBuckBunny_320x180.UYVY.enc.jpeg";
            inFilename = "BigBuckBunny_1920x1080.UYVY.enc.jpeg";
            //inFilename = "BigBuckBunny_3840x2160.UYVY.enc.jpeg";
            string outFilename = Path.ChangeExtension(inFilename, ".yuv");

            Console.WriteLine("Working directory: {0}", Environment.CurrentDirectory);
            Console.WriteLine("Input filename: {0}", inFilename);
            Console.WriteLine();

            if (!File.Exists(inFilename))
            {
                Console.WriteLine("Input file not found. Press any key to exit.");
                Console.ReadKey();
                return;
            }


            Stream         infs, outfs;
            BenchmarkTimer bt = null;


#if !ENABLE_BENCHMARK
            infs  = File.Open(inFilename, FileMode.Open);
            outfs = File.Open(outFilename, FileMode.Create);
#else       // delete this code for most simple example
            // * Benchmark Mode *
            // this block does a couple things:
            //   1. causes the file to be pre-read into memory so we are not timing disk reads.
            //   2. replaces the output stream with a NullStream so nothing gets written to disk.
            //   3. Starts the timer for benchmarking
            // this pre-reads file into memory for benchmarking
            long maximumMemoryToAllocate = (long)4L * 1024 * 1024 * 1024;
            Console.WriteLine("Pre-reading input");
            infs = new PreReadLargeMemoryStream(File.Open(inFilename, FileMode.Open), maximumMemoryToAllocate);



            Console.WriteLine("Input read");

            outfs = new NullStream();
            bt    = new BenchmarkTimer();
            bt.Start();

            int minimumFrames = 4000;
#endif



            Console.WriteLine("Output filename: {0}",
                              Path.GetFileName((outfs as FileStream)?.Name ?? "NO OUTPUT"));
            Console.WriteLine();

            var outIOPattern = IOPattern.MFX_IOPATTERN_OUT_SYSTEM_MEMORY;


            // The encoder cannot encode UYVY, but if you are the only decoder of the JPEG
            // files, you can encode UYVY as YUY2 and everything is good.
            if (fourcc == FourCC.UYVY)
            {
                fourcc = FourCC.YUY2;
            }

            mfxVideoParam decoderParameters = QuickSyncStatic.ReadFileHeaderInfo(codecId, impl, infs, outIOPattern);
            decoderParameters.mfx.FrameInfo.FourCC = fourcc;

            AssignChromaFormat(fourcc, ref decoderParameters);


            var decoder = new StreamDecoder(infs, decoderParameters, null, impl);

#if ENABLE_BENCHMARK     // delete this code for most simple example
            decoder.benchmarkNeverStopMode = true;
#endif

            string impltext = QuickSyncStatic.ImplementationString(decoder.lowLevelDecoder.session);
            Console.WriteLine("Implementation = {0}", impltext);

            // not needed
            //var formatConverter = new NV12ToXXXXConverter(fourcc, decoder.width, decoder.height);

            int width  = decoderParameters.mfx.FrameInfo.CropW;
            int height = decoderParameters.mfx.FrameInfo.CropH;
            var tmpbuf = new byte[width * height * 2];

            int count = 0;

            foreach (var frame in decoder.GetFrames())
            {
                //var frameBytes = formatConverter.ConvertFromNV12(frame.Data);        // Convert to format requested


                Trace.Assert(frame.Data.Pitch == width * 2);  // yuy2 only

                fixed(byte *aa = &tmpbuf[0])
                FastMemcpyMemmove.memcpy((IntPtr)aa, frame.Data.Y, height * width * 2);

                outfs.Write(tmpbuf, 0, tmpbuf.Length);

                if (++count % 100 == 0)
                {
                    Console.Write("Frame {0}\r", count);
                }

#if ENABLE_BENCHMARK     // delete this code for most simple example
                if (count > minimumFrames)
                {
                    break;
                }
#endif
            }

            if (bt != null)
            {
                bt.StopAndReport(count, infs.Position, outfs.Position);
            }

            infs.Close();
            outfs.Close();

            Console.WriteLine("Decoded {0} frames", count);

            // make sure program always waits for user, except F5-Release run
            if (Debugger.IsAttached ||
                Environment.GetEnvironmentVariable("VisualStudioVersion") == null)
            {
                Console.WriteLine("done - press a key to exit");
                Console.ReadKey();
            }
        }