public IHardwareDeviceSession OpenDeviceSession(Direction direction, IVirtualMemoryManager memoryManager, SampleFormat sampleFormat, uint sampleRate, uint channelCount) { if (channelCount == 0) { channelCount = 2; } if (sampleRate == 0) { sampleRate = Constants.TargetSampleRate; } if (direction != Direction.Output) { throw new ArgumentException($"{direction}"); } else if (!SupportsChannelCount(channelCount)) { throw new ArgumentException($"{channelCount}"); } lock (_lock) { OpenALHardwareDeviceSession session = new OpenALHardwareDeviceSession(this, memoryManager, sampleFormat, sampleRate, channelCount); _sessions.Add(session); return(session); } }
private uint ListAudioInsImpl(IVirtualMemoryManager memory, long bufferPosition, long bufferSize, bool filtered = false) { uint count = 0; MemoryHelper.FillWithZeros(memory, bufferPosition, (int)bufferSize); if (bufferSize > 0) { // NOTE: The service also check that the input target is enabled when in filtering mode, as audctl and most of the audin logic isn't supported, we don't support it. if (!filtered) { byte[] deviceNameBuffer = Encoding.ASCII.GetBytes(DefaultAudioInsName + "\0"); memory.Write((ulong)bufferPosition, deviceNameBuffer); count++; } // NOTE: The service adds other input devices names available in the buffer, // every name is aligned to 0x100 bytes. // Since we don't support it for now, it's fine to do nothing here. } return(count); }
public IRoInterface(ServiceCtx context) { _nrrInfos = new List <NrrInfo>(MaxNrr); _nroInfos = new List <NroInfo>(MaxNro); _owner = null; _ownerMm = null; }
private void DeserializeAddrInfos(IVirtualMemoryManager memory, ulong address, ulong size) { ulong endAddress = address + size; while (address < endAddress) { AddrInfoSerializedHeader header = memory.Read <AddrInfoSerializedHeader>(address); if (header.Magic != SfdnsresContants.AddrInfoMagic) { break; } address += (ulong)Unsafe.SizeOf <AddrInfoSerializedHeader>() + header.AddressLength; // ai_canonname string canonname = string.Empty; while (true) { byte chr = memory.Read <byte>(address++); if (chr == 0) { break; } canonname += (char)chr; } } }
public HardwareDeviceSessionOutputBase(IVirtualMemoryManager memoryManager, SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount) { MemoryManager = memoryManager; RequestedSampleFormat = requestedSampleFormat; RequestedSampleRate = requestedSampleRate; RequestedChannelCount = requestedChannelCount; }
/// <summary> /// Create a new tracking structure for the given "physical" memory block, /// with a given "virtual" memory manager that will provide mappings and virtual memory protection. /// </summary> /// <param name="memoryManager">Virtual memory manager</param> /// <param name="block">Physical memory block</param> /// <param name="pageSize">Page size of the virtual memory space</param> public MemoryTracking(IVirtualMemoryManager memoryManager, int pageSize) { _memoryManager = memoryManager; _pageSize = pageSize; _virtualRegions = new NonOverlappingRangeList <VirtualRegion>(); }
public IHardwareDeviceSession OpenDeviceSession(Direction direction, IVirtualMemoryManager memoryManager, SampleFormat sampleFormat, uint sampleRate, uint channelCount) { if (channelCount == 0) { channelCount = 2; } if (sampleRate == 0) { sampleRate = Constants.TargetSampleRate; } if (direction != Direction.Output) { throw new NotImplementedException("Input direction is currently not implemented on SoundIO backend!"); } lock (_lock) { SoundIoHardwareDeviceSession session = new SoundIoHardwareDeviceSession(this, memoryManager, sampleFormat, sampleRate, channelCount); _sessions.Add(session); return(session); } }
public bool DrawTo(RenderingSurfaceInfo surfaceInfo, IVirtualMemoryManager destination, ulong position) { _npads?.Update(); _keyboardRenderer?.SetSurfaceInfo(surfaceInfo); return(_keyboardRenderer?.DrawTo(destination, position) ?? false); }
/// <summary> /// Create a new tracking structure for the given "physical" memory block, /// with a given "virtual" memory manager that will provide mappings and virtual memory protection. /// </summary> /// <param name="memoryManager">Virtual memory manager</param> /// <param name="block">Physical memory block</param> /// <param name="pageSize">Page size of the virtual memory space</param> public MemoryTracking(IVirtualMemoryManager memoryManager, int pageSize, InvalidAccessHandler invalidAccessHandler = null) { _memoryManager = memoryManager; _pageSize = pageSize; _invalidAccessHandler = invalidAccessHandler; _virtualRegions = new NonOverlappingRangeList <VirtualRegion>(); }
public SoundIoHardwareDeviceSession(SoundIoHardwareDeviceDriver driver, IVirtualMemoryManager memoryManager, SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount) : base(memoryManager, requestedSampleFormat, requestedSampleRate, requestedChannelCount) { _driver = driver; _updateRequiredEvent = _driver.GetUpdateRequiredEvent(); _queuedBuffers = new ConcurrentQueue <SoundIoAudioBuffer>(); _ringBuffer = new DynamicRingBuffer(); SetupOutputStream(); }
public OpenALHardwareDeviceSession(OpenALHardwareDeviceDriver driver, IVirtualMemoryManager memoryManager, SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount) : base(memoryManager, requestedSampleFormat, requestedSampleRate, requestedChannelCount) { _driver = driver; _queuedBuffers = new Queue <OpenALAudioBuffer>(); _sourceId = AL.GenSource(); _targetFormat = GetALFormat(); _isActive = false; _playedSampleCount = 0; }
/// <summary> /// Create a new tracking structure for the given "physical" memory block, /// with a given "virtual" memory manager that will provide mappings and virtual memory protection. /// </summary> /// <param name="memoryManager">Virtual memory manager</param> /// <param name="block">Physical memory block</param> /// <param name="pageSize">Page size of the virtual memory space</param> public MemoryTracking(IVirtualMemoryManager memoryManager, MemoryBlock block, int pageSize) { _memoryManager = memoryManager; _block = block; _pageSize = pageSize; _virtualRegions = new NonOverlappingRangeList <VirtualRegion>(); _physicalRegions = new NonOverlappingRangeList <PhysicalRegion>(); }
public CommandList(IVirtualMemoryManager memoryManager, Memory <float> mixBuffer, uint sampleCount, uint sampleRate, uint mixBufferCount, uint voiceChannelCountMax) { SampleCount = sampleCount; SampleRate = sampleRate; BufferCount = mixBufferCount + voiceChannelCountMax; Buffers = mixBuffer; Commands = new List <ICommand>(); MemoryManager = memoryManager; }
public NvHostChannelDeviceFile(ServiceCtx context, IVirtualMemoryManager memory, long owner) : base(context, owner) { _device = context.Device; _memory = memory; _timeout = 3000; _submitTimeout = 0; _timeslice = 0; ChannelSyncpoints = new uint[MaxModuleSyncpoint]; _channelSyncpoint.Id = _device.System.HostSyncpoint.AllocateSyncpoint(false); _channelSyncpoint.UpdateValue(_device.System.HostSyncpoint); }
public CommandList(IVirtualMemoryManager memoryManager, Memory <float> mixBuffer, uint sampleCount, uint sampleRate, uint mixBufferCount, uint voiceChannelCountMax) { SampleCount = sampleCount; _sampleCount = (int)SampleCount; SampleRate = sampleRate; BufferCount = mixBufferCount + voiceChannelCountMax; Buffers = mixBuffer; Commands = new List <ICommand>(); MemoryManager = memoryManager; _buffersEntryCount = Buffers.Length; _buffersMemoryHandle = Buffers.Pin(); }
public unsafe static void Write <T>(IVirtualMemoryManager memory, long position, T value) where T : struct { long size = Marshal.SizeOf <T>(); byte[] data = new byte[size]; fixed(byte *ptr = data) { Marshal.StructureToPtr <T>(value, (IntPtr)ptr, false); } memory.Write((ulong)position, data); }
public SDL2HardwareDeviceSession(SDL2HardwareDeviceDriver driver, IVirtualMemoryManager memoryManager, SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount, float requestedVolume) : base(memoryManager, requestedSampleFormat, requestedSampleRate, requestedChannelCount) { _driver = driver; _updateRequiredEvent = _driver.GetUpdateRequiredEvent(); _queuedBuffers = new ConcurrentQueue <SDL2AudioBuffer>(); _ringBuffer = new DynamicRingBuffer(); _callbackDelegate = Update; _bytesPerFrame = BackendHelper.GetSampleSize(RequestedSampleFormat) * (int)RequestedChannelCount; _nativeSampleFormat = SDL2HardwareDeviceDriver.GetSDL2Format(RequestedSampleFormat); _sampleCount = uint.MaxValue; _started = false; _volume = requestedVolume; }
public unsafe static T Read <T>(IVirtualMemoryManager memory, ulong position) where T : struct { long size = Marshal.SizeOf <T>(); byte[] data = new byte[size]; memory.Read(position, data); fixed(byte *ptr = data) { return(Marshal.PtrToStructure <T>((IntPtr)ptr)); } }
public static void FillWithZeros(IVirtualMemoryManager memory, ulong position, int size) { int size8 = size & ~(8 - 1); for (int offs = 0; offs < size8; offs += 8) { memory.Write <long>(position + (ulong)offs, 0); } for (int offs = size8; offs < (size - size8); offs++) { memory.Write <byte>(position + (ulong)offs, 0); } }
public NvHostCtrlDeviceFile(ServiceCtx context, IVirtualMemoryManager memory, long owner) : base(context, owner) { if (NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object productionModeSetting)) { _isProductionMode = ((string)productionModeSetting) != "0"; // Default value is "" } else { _isProductionMode = true; } _device = context.Device; _events = new NvHostEvent[EventsCount]; }
private ElfSymbol GetSymbol32(IVirtualMemoryManager memory, ulong address, ulong strTblAddr) { ElfSymbol32 sym = memory.Read <ElfSymbol32>(address); uint nameIndex = sym.NameOffset; string name = string.Empty; for (int chr; (chr = memory.Read <byte>(strTblAddr + nameIndex++)) != 0;) { name += (char)chr; } return(new ElfSymbol(name, sym.Info, sym.Other, sym.SectionIndex, sym.ValueAddress, sym.Size)); }
internal bool DrawTo(RenderingSurfaceInfo surfaceInfo, IVirtualMemoryManager destination, ulong position) { lock (_renderLock) { if (!_surfaceInfo.Equals(surfaceInfo)) { _surfaceInfo = surfaceInfo; RecreateSurface(); RecomputeConstants(); } Redraw(); return(TryCopyTo(destination, position)); } }
private static void ZeroFill(IVirtualMemoryManager memoryManager, ulong address, int size) { ulong endAddress = address + (ulong)size; while (address + 7UL < endAddress) { memoryManager.Write(address, 0UL); address += 8; } while (address < endAddress) { memoryManager.Write(address, (byte)0); address++; } }
/// <summary> /// Open a new <see cref="AudioOutputSystem"/>. /// </summary> /// <param name="outputDeviceName">The output device name selected by the <see cref="AudioOutputSystem"/></param> /// <param name="outputConfiguration">The output audio configuration selected by the <see cref="AudioOutputSystem"/></param> /// <param name="obj">The new <see cref="AudioOutputSystem"/></param> /// <param name="memoryManager">The memory manager that will be used for all guest memory operations</param> /// <param name="inputDeviceName">The input device name wanted by the user</param> /// <param name="sampleFormat">The sample format to use</param> /// <param name="parameter">The user configuration</param> /// <param name="appletResourceUserId">The applet resource user id of the application</param> /// <param name="processHandle">The process handle of the application</param> /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns> public ResultCode OpenAudioOut(out string outputDeviceName, out AudioOutputConfiguration outputConfiguration, out AudioOutputSystem obj, IVirtualMemoryManager memoryManager, string inputDeviceName, SampleFormat sampleFormat, ref AudioInputConfiguration parameter, ulong appletResourceUserId, uint processHandle, float volume) { int sessionId = AcquireSessionId(); _sessionsBufferEvents[sessionId].Clear(); IHardwareDeviceSession deviceSession = _deviceDriver.OpenDeviceSession(IHardwareDeviceDriver.Direction.Output, memoryManager, sampleFormat, parameter.SampleRate, parameter.ChannelCount, volume); AudioOutputSystem audioOut = new AudioOutputSystem(this, _lock, deviceSession, _sessionsBufferEvents[sessionId]); ResultCode result = audioOut.Initialize(inputDeviceName, sampleFormat, ref parameter, sessionId); if (result == ResultCode.Success) { outputDeviceName = audioOut.DeviceName; outputConfiguration = new AudioOutputConfiguration { ChannelCount = audioOut.ChannelCount, SampleFormat = audioOut.SampleFormat, SampleRate = audioOut.SampleRate, AudioOutState = audioOut.GetState(), }; obj = audioOut; Register(audioOut); } else { ReleaseSessionId(sessionId); obj = null; outputDeviceName = null; outputConfiguration = default; } return(result); }
public void Borrow(KProcess dstProcess, ulong va) { ulong currentOffset = 0; foreach (KPageNode pageNode in _pageList) { ulong address = pageNode.Address - DramMemoryMap.DramBase; ulong size = pageNode.PagesCount * KPageTableBase.PageSize; dstProcess.CpuMemory.Write(va + currentOffset, _context.Memory.GetSpan(address + currentOffset, (int)size)); currentOffset += size; } _borrowerMemory = dstProcess.CpuMemory; _borrowerVa = va; }
public ServiceCtx( Switch device, KProcess process, IVirtualMemoryManager memory, KThread thread, IpcMessage request, IpcMessage response, BinaryReader requestData, BinaryWriter responseData) { Device = device; Process = process; Memory = memory; Thread = thread; Request = request; Response = response; RequestData = requestData; ResponseData = responseData; }
public static string ReadAsciiString(IVirtualMemoryManager memory, ulong position, long maxSize = -1) { using (MemoryStream ms = new MemoryStream()) { for (long offs = 0; offs < maxSize || maxSize == -1; offs++) { byte value = memory.Read <byte>(position + (ulong)offs); if (value == 0) { break; } ms.WriteByte(value); } return(Encoding.ASCII.GetString(ms.ToArray())); } }
private static void DeserializeAddrInfos(IVirtualMemoryManager memory, ulong address, ulong size) { ulong endAddress = address + size; while (address < endAddress) { AddrInfoSerializedHeader header = memory.Read <AddrInfoSerializedHeader>(address); if (header.Magic != SfdnsresContants.AddrInfoMagic) { break; } address += (ulong)Unsafe.SizeOf <AddrInfoSerializedHeader>() + header.AddressLength; // ai_canonname string canonname = MemoryHelper.ReadAsciiString(memory, address); } }
// Initialize(u64, pid, KObject) public ResultCode Initialize(ServiceCtx context) { if (_owner != null) { return(ResultCode.InvalidSession); } int processHandle = context.Request.HandleDesc.ToCopy[0]; _owner = context.Process.HandleTable.GetKProcess(processHandle); _ownerMm = _owner?.CpuMemory; context.Device.System.KernelContext.Syscall.CloseHandle(processHandle); if (_ownerMm is IRefCounted rc) { rc.IncrementReferenceCount(); } return(ResultCode.Success); }
private static List <AddrInfoSerialized> DeserializeAddrInfos(IVirtualMemoryManager memory, ulong address, ulong size) { List <AddrInfoSerialized> result = new List <AddrInfoSerialized>(); ReadOnlySpan <byte> data = memory.GetSpan(address, (int)size); while (!data.IsEmpty) { AddrInfoSerialized info = AddrInfoSerialized.Read(data, out data); if (info == null) { break; } result.Add(info); } return(result); }