public static ResultCode OpenNcaFs(ServiceCtx context, string ncaPath, LibHac.Fs.IStorage ncaStorage, out IFileSystem openedFileSystem) { openedFileSystem = null; try { Nca nca = new Nca(context.Device.System.KeySet, ncaStorage); if (!nca.SectionExists(NcaSectionType.Data)) { return(ResultCode.PartitionNotFound); } LibHac.Fs.Fsa.IFileSystem fileSystem = nca.OpenFileSystem(NcaSectionType.Data, context.Device.System.FsIntegrityCheckLevel); using var sharedFs = new SharedRef <LibHac.Fs.Fsa.IFileSystem>(fileSystem); using SharedRef <LibHac.FsSrv.Sf.IFileSystem> adapter = FileSystemInterfaceAdapter.CreateShared(ref sharedFs.Ref(), true); openedFileSystem = new IFileSystem(ref adapter.Ref()); } catch (HorizonResultException ex) { return((ResultCode)ex.ResultValue.Value); } return(ResultCode.Success); }
[CommandHipc(1)] // 6.0.0+ // Add(object<nn::fssrv::sf::IFileSystem>) public ResultCode Add(ServiceCtx context) { using SharedRef <LibHac.FsSrv.Sf.IFileSystem> fileSystem = GetObject <IFileSystem>(context, 0).GetBaseFileSystem(); Result result = _baseCommitManager.Get.Add(ref fileSystem.Ref()); return((ResultCode)result.Value); }
/// <summary> /// Creates an instance of this class that holds the given image. /// </summary> /// <param name="image">Image argument. /// Copies of the given instance are created when the image is used through the respective property of this class.</param> public ImageProcessedEventArgs(SharedRef <IRasterImageBase> image) { if (image == null) { throw new ArgumentNullException("image"); } this.image = image; }
// CreateDirectoryService() -> object<nn::bcat::detail::ipc::IDeliveryCacheDirectoryService> public ResultCode CreateDirectoryService(ServiceCtx context) { using var service = new SharedRef <LibHac.Bcat.Impl.Ipc.IDeliveryCacheDirectoryService>(); Result result = _base.Get.CreateDirectoryService(ref service.Ref()); if (result.IsSuccess()) { MakeObject(context, new IDeliveryCacheDirectoryService(ref service.Ref())); } return((ResultCode)result.Value); }
private void SetupStep(SharedRef <IRasterImageBase> imageIn) { IRasterImageBase imgIn = imageIn.Reference; IRasterImageBase imgOut = imageOut.Reference; if (imgIn.Width != imgOut.Width || imgIn.Height != imgOut.Height) { imageCleaner.AddReference(imageOut); imageCleaner.CleanUpAll(); IRasterImageBase frame = new TrackerVideoFrame(imgIn.Height, imgIn.Width, new byte[imgIn.Height * imgIn.Width]); imageOut = SharedRef.Create(frame); } }
// CreateDeliveryCacheStorageService(pid) -> object<nn::bcat::detail::ipc::IDeliveryCacheStorageService> public ResultCode CreateDeliveryCacheStorageService(ServiceCtx context) { ulong pid = context.RequestData.ReadUInt64(); using var serv = new SharedRef <LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService>(); Result rc = _base.Get.CreateDeliveryCacheStorageService(ref serv.Ref(), pid); if (rc.IsSuccess()) { MakeObject(context, new IDeliveryCacheStorageService(context, ref serv.Ref())); } return((ResultCode)rc.Value); }
// CreateDeliveryCacheStorageServiceWithApplicationId(nn::ApplicationId) -> object<nn::bcat::detail::ipc::IDeliveryCacheStorageService> public ResultCode CreateDeliveryCacheStorageServiceWithApplicationId(ServiceCtx context) { ApplicationId applicationId = context.RequestData.ReadStruct <ApplicationId>(); using var service = new SharedRef <LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService>(); Result rc = _base.Get.CreateDeliveryCacheStorageServiceWithApplicationId(ref service.Ref(), applicationId); if (rc.IsSuccess()) { MakeObject(context, new IDeliveryCacheStorageService(context, ref service.Ref())); } return((ResultCode)rc.Value); }
public P3CapTracker(EquipmentSettings settings) : base() { if (settings == null) { throw new ArgumentNullException("settings"); } this.settings = new EquipmentSettings(settings); this.pointDetector = null; this.pointLabeler = null; this.poseEstimator = null; IRasterImageBase frame = new TrackerVideoFrame(1, 1, new byte[1]); this.imageOut = SharedRef.Create(frame); this.imageCleaner = new SharedRefCleaner(32); this.trackerSync = new object(); }
public void Run() { Task t1, t2, t3; // create 2 objects Console.WriteLine("{0}: starting initial scope", Thread.CurrentThread.ManagedThreadId); using (var o1 = SharedRef.Create(new MyDisposable("o1"))) using (var o2 = SharedRef.Create(new MyDisposable("o2"))) { // and 3 sharedrefs, which will be Disposed in 3 separate threads var p1 = SharedRef.Create(o1); var p2a = SharedRef.Create(o2); var p2b = SharedRef.Create(o2); t1 = Task.Run(() => { using (p1) { Console.WriteLine("{0}: in another thread, using o1", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(1000); Console.WriteLine("{0}: in another thread, exiting scope", Thread.CurrentThread.ManagedThreadId); } }); t2 = Task.Run(() => { using (p2a) { Console.WriteLine("{0}: in another thread, using o2", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(1000); Console.WriteLine("{0}: in another thread, exiting scope", Thread.CurrentThread.ManagedThreadId); } }); t3 = Task.Run(() => { using (p2b) { Console.WriteLine("{0}: in another thread, using o2", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(1000); Console.WriteLine("{0}: in another thread, exiting scope", Thread.CurrentThread.ManagedThreadId); } }); Console.WriteLine("{0}: exiting initial scope", Thread.CurrentThread.ManagedThreadId); } t1.Wait(); t2.Wait(); t3.Wait(); }
internal async Task <Server[]> ConnectAsync(bool reconnect, bool resumable) { if (reconnect) { _dispatcher?.TearDown(); } var loop = new SharedRef <bool>(false); int loops = 0; DiscordDebug.WriteLine("Starting connection appempt..."); Server[] res = null; do { if (loops >= _maxConnectAttempts) { throw new GatewayConnectException("Gateway failed to connect " + _maxConnectAttempts + " times, and the connection attempt was aborted."); } loop.Value = false; await _connectMutex.WaitAsync(); if (_listener == null) { string url = await GetGatewayUrlAsync(); DiscordDebug.WriteLine("Opening socket..."); var socket = new GatewaySocket(this); socket.Connect(url); if (socket.State == WebSocketState.Open) { DiscordDebug.WriteLine("Socket opened."); res = await HandshakeAsync(reconnect, resumable, socket, loop); } else { DiscordDebug.WriteLine("Socket opening failed, trying again..."); loop.Value = true; } } _connectMutex.Release(); loops++; } while (loop.Value); DiscordDebug.WriteLine("Connection attempt done."); // ReSharper disable once AssignNullToNotNullAttribute (null value is default to get compiler to shut up - whenever res is null, the loop should continue) return(res); }
public void QueueInput(SharedRef <IRasterImageBase> image) { if (image == null) { throw new ArgumentNullException("image"); } if (!Running) { return; } lock (inputSync) { pendingImages.Enqueue(SharedRef.Copy(image)); // TODO: get limit efficiently int imageLimit = 4; //GetSettings().GetInteger(TrackerProperty.MaxQueuedImages, 4); while (pendingImages.Count > imageLimit && pendingImages.Count >= 0) { pendingImages.Dequeue().Dispose(); } } OnInputAvailable(new EventArgs()); }
public static ResultCode OpenNsp(ServiceCtx context, string pfsPath, out IFileSystem openedFileSystem) { openedFileSystem = null; try { LocalStorage storage = new LocalStorage(pfsPath, FileAccess.Read, FileMode.Open); using SharedRef <LibHac.Fs.Fsa.IFileSystem> nsp = new(new PartitionFileSystem(storage)); ImportTitleKeysFromNsp(nsp.Get, context.Device.System.KeySet); using SharedRef <LibHac.FsSrv.Sf.IFileSystem> adapter = FileSystemInterfaceAdapter.CreateShared(ref nsp.Ref(), true); openedFileSystem = new IFileSystem(ref adapter.Ref()); } catch (HorizonResultException ex) { return((ResultCode)ex.ResultValue.Value); } return(ResultCode.Success); }
public override bool Step() { if (!Running) { return(false); } SharedRef <IRasterImageBase> image = null; lock (inputSync) { if (pendingImages.Count > 0) { image = pendingImages.Dequeue(); } } while (image != null) { using (image) { bool result = false; if (image.Reference != null) { result = Step(image); return(true); } } lock (inputSync) { if (pendingImages.Count > 0) { image = pendingImages.Dequeue(); } else { image = null; } } } return(false); }
protected override bool Step(SharedRef <IRasterImageBase> imageIn) { if (!Running) { return(false); } SetupStep(imageIn); // keypoint detection Point2i[] keypoints; int keypointNo = pointDetector.Detect(imageIn.Reference, imageOut.Reference, out keypoints); // keypoint labeling int[] labels; int labelNo = pointLabeler.Label(keypoints, keypointNo, imageOut.Reference, out labels); // TODO: pose detection var position = poseEstimator.Estimate(keypoints, labels, labelNo); // spread results OnInputProcessed(new ImageProcessedEventArgs(imageOut)); OnPositionDetected(new PositionDetectedEventArgs(position)); return(true); }
public IDirectory(ref SharedRef <LibHac.FsSrv.Sf.IDirectory> directory) { _baseDirectory = SharedRef <LibHac.FsSrv.Sf.IDirectory> .CreateMove(ref directory); }
public IDeviceOperator(ref SharedRef <LibHac.FsSrv.Sf.IDeviceOperator> baseOperator) { _baseOperator = SharedRef <LibHac.FsSrv.Sf.IDeviceOperator> .CreateMove(ref baseOperator); }
public Result GetServiceObject(ref SharedRef <IDisposable> serviceObject) { serviceObject.SetByCopy(in _serviceObject); return(Result.Success); }
public LibHacArpServiceObject(ref SharedRef <LibHacIReader> serviceObject) { _serviceObject = SharedRef <LibHacIReader> .CreateCopy(in serviceObject); }
/// <summary> /// Processes the given image. /// </summary> /// <returns>Whether the operation was successful.</returns> /// <param name="image">Image ready for processing. Disposed after the method returns.</param> protected abstract bool Step(SharedRef <IRasterImageBase> image);
public T Get(SharedRef <T> objRef) { return(m_SharedRefs[objRef.Id]); }
public IStorage(ref SharedRef <LibHac.FsSrv.Sf.IStorage> baseStorage) { _baseStorage = SharedRef <LibHac.FsSrv.Sf.IStorage> .CreateMove(ref baseStorage); }
public ISaveDataInfoReader(ref SharedRef <LibHac.FsSrv.Sf.ISaveDataInfoReader> baseReader) { _baseReader = SharedRef <LibHac.FsSrv.Sf.ISaveDataInfoReader> .CreateMove(ref baseReader); }
/// <summary> /// Create a SharedRef from a previous SharedRef, incrementing the reference count. /// </summary> /// <param name="o"></param> public SharedRef(SharedRef <T> o) { o._t.Retain(); _t = o._t; }
public void LoadKip(string kipPath) { using var kipFile = new SharedRef <IStorage>(new LocalStorage(kipPath, FileAccess.Read)); ProgramLoader.LoadKip(KernelContext, new KipExecutable(in kipFile)); }
public IDeliveryCacheStorageService(ServiceCtx context, ref SharedRef <LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService> baseService) { _base = SharedRef <LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService> .CreateMove(ref baseService); }
public void Remove(SharedRef <T> objRef) { m_SharedRefs.Remove(objRef.Id); }
public Result Create(ref SharedRef <IFileSystem> outEncryptedFileSystem, ref SharedRef <IFileSystem> baseFileSystem, IEncryptedFileSystemCreator.KeyId idIndex, in EncryptionSeed encryptionSeed)
public IFileSystem(ref SharedRef <LibHac.FsSrv.Sf.IFileSystem> provider) { _fileSystem = SharedRef <LibHac.FsSrv.Sf.IFileSystem> .CreateMove(ref provider); }
public IDeliveryCacheFileService(ref SharedRef <LibHac.Bcat.Impl.Ipc.IDeliveryCacheFileService> baseService) { _base = SharedRef <LibHac.Bcat.Impl.Ipc.IDeliveryCacheFileService> .CreateMove(ref baseService); }
public IMultiCommitManager(ref SharedRef <LibHac.FsSrv.Sf.IMultiCommitManager> baseCommitManager) { _baseCommitManager = SharedRef <LibHac.FsSrv.Sf.IMultiCommitManager> .CreateMove(ref baseCommitManager); }