+using System.IO;

+

+namespace Ryujinx.Common.Utilities

+{

+ public static class StreamUtils

+ {

+ public static byte[] StreamToBytes(Stream input)

+ {

+ using (MemoryStream stream = new MemoryStream())

+ {

+ input.CopyTo(stream);

+

+ return stream.ToArray();

+ }

+ }

+ }

+} \ No newline at end of file

+} \ No newline at end of file

+} \ No newline at end of file

+} \ No newline at end of file

+ public InvalidStructLayoutException(string message) : base(message) { }

+ public InvalidStructLayoutException(int expectedSize)

+ : base($"Type {_structType.Name} has the wrong size. Expected: {expectedSize} bytes, got: {Unsafe.SizeOf<T>()} bytes") { }

+ : this(service, context, "The service call is not implemented.") { }

+ public ServiceNotImplementedException(IpcService service, ServiceCtx context, string message) : base(message)

+ public ServiceNotImplementedException(IpcService service, ServiceCtx context, string message, Exception inner) : base(message, inner)

+ protected ServiceNotImplementedException(SerializationInfo info, StreamingContext context) : base(info, context) { }

+ return base.Message + Environment.NewLine + Environment.NewLine + BuildMessage();

+ var ipcCommands = Request.Type > IpcMessageType.TipcCloseSession ? Service.TipcCommands : Service.HipcCommands;

+ if (Request.PtrBuff.Count > 0 ||

+ Request.SendBuff.Count > 0 ||

+ Request.ReceiveBuff.Count > 0 ||

+ private static (Type, MethodBase) WalkStackTrace(StackTrace trace)

+

+} \ No newline at end of file

+} \ No newline at end of file

+} \ No newline at end of file

+ device.System.SharedFontManager.Initialize();

+ public HLEConfiguration(VirtualFileSystem virtualFileSystem,

+ LibHacHorizonManager libHacHorizonManager,

+ ContentManager contentManager,

+ AccountManager accountManager,

+ IRenderer gpuRenderer,

+ IHardwareDeviceDriver audioDeviceDriver,

+ MemoryConfiguration memoryConfiguration,

+ IHostUiHandler hostUiHandler,

+ SystemLanguage systemLanguage,

+ RegionCode region,

+ bool enableVsync,

+ bool enableDockedMode,

+ bool enablePtc,

+ IntegrityCheckLevel fsIntegrityCheckLevel,

+ int fsGlobalAccessLogMode,

+ long systemTimeOffset,

+ string timeZone,

+ MemoryManagerMode memoryManagerMode,

+ bool ignoreMissingServices,

+ AspectRatio aspectRatio)

+ VirtualFileSystem = virtualFileSystem;

+ LibHacHorizonManager = libHacHorizonManager;

+ AccountManager = accountManager;

+ ContentManager = contentManager;

+ GpuRenderer = gpuRenderer;

+ AudioDeviceDriver = audioDeviceDriver;

+ MemoryConfiguration = memoryConfiguration;

+ HostUiHandler = hostUiHandler;

+ SystemLanguage = systemLanguage;

+ Region = region;

+ EnableVsync = enableVsync;

+ EnableDockedMode = enableDockedMode;

+ EnablePtc = enablePtc;

+ FsIntegrityCheckLevel = fsIntegrityCheckLevel;

+ FsGlobalAccessLogMode = fsGlobalAccessLogMode;

+ SystemTimeOffset = systemTimeOffset;

+ TimeZone = timeZone;

+ MemoryManagerMode = memoryManagerMode;

+ IgnoreMissingServices = ignoreMissingServices;

+ AspectRatio = aspectRatio;

+} \ No newline at end of file

+using Ryujinx.HLE.HOS.Services.Sdb.Pl;

+ internal SharedFontManager SharedFontManager { get; private set; }

+ internal AccountManager AccountManager { get; private set; }

+ internal ContentManager ContentManager { get; private set; }

+ internal CaptureManager CaptureManager { get; private set; }

+ SharedFontManager = new SharedFontManager(device, fontStorage);

+ AccountManager = device.Configuration.AccountManager;

+ ContentManager = device.Configuration.ContentManager;

+ CaptureManager = new CaptureManager(device);

+ public HorizonClient RyujinxClient { get; private set; }

+ public HorizonClient AccountClient { get; private set; }

+ public HorizonClient AmClient { get; private set; }

+ public HorizonClient BcatClient { get; private set; }

+ public HorizonClient FsClient { get; private set; }

+ public HorizonClient NsClient { get; private set; }

+ public HorizonClient SdbClient { get; private set; }

+ BcatClient = Server.CreateHorizonClient(new ProgramLocation(SystemProgramId.Bcat, StorageId.BuiltInSystem), BcatFsPermissions);

+ AccountClient = Server.CreateHorizonClient(new ProgramLocation(SystemProgramId.Account, StorageId.BuiltInSystem), AccountFsPermissions);

+ AmClient = Server.CreateHorizonClient(new ProgramLocation(SystemProgramId.Am, StorageId.BuiltInSystem), AmFsPermissions);

+ NsClient = Server.CreateHorizonClient(new ProgramLocation(SystemProgramId.Ns, StorageId.BuiltInSystem), NsFsPermissions);

+ SdbClient = Server.CreateHorizonClient(new ProgramLocation(SystemProgramId.Sdb, StorageId.BuiltInSystem), SdbFacData, SdbFacDescriptor);

+ ApplicationClient = Server.CreateHorizonClient(new ProgramLocation(programId, StorageId.BuiltInUser), npdm.FsAccessControlData, npdm.FsAccessControlDescriptor);

+} \ No newline at end of file

+ public Switch Device { get; }

+ public KProcess Process { get; }

+ public IVirtualMemoryManager Memory { get; }

+ public KThread Thread { get; }

+ public IpcMessage Request { get; }

+ public IpcMessage Response { get; }

+ public BinaryReader RequestData { get; }

+ public BinaryWriter ResponseData { get; }

+ Switch device,

+ KProcess process,

+ KThread thread,

+ IpcMessage request,

+ IpcMessage response,

+ BinaryReader requestData,

+ BinaryWriter responseData)

+ Device = device;

+ Process = process;

+ Memory = memory;

+ Thread = thread;

+ Request = request;

+ Response = response;

+ RequestData = requestData;

+ NrrHeader header = _owner.CpuMemory.Read<NrrHeader>(nrrAddress);

+using Ryujinx.HLE.HOS.Services.Sdb.Pl.Types;

+ context.ResponseData.Write(context.Device.System.SharedFontManager.GetFontSize(fontType));

+ context.ResponseData.Write(context.Device.System.SharedFontManager.GetSharedMemoryAddressOffset(fontType));

+ context.Device.System.SharedFontManager.EnsureInitialized(context.Device.System.ContentManager);

+ context.Memory.Write(offsetsPosition + offset, context.Device.System.SharedFontManager.GetSharedMemoryAddressOffset(fontType));

+ context.Memory.Write(fontSizeBufferPosition + offset, context.Device.System.SharedFontManager.GetFontSize(fontType));

+using Ryujinx.HLE.HOS.Services.Sdb.Pl.Types;

+namespace Ryujinx.HLE.HOS.Services.Sdb.Pl

+ private static readonly uint FontKey = 0x06186249;

+ private static readonly uint BFTTFMagic = 0x18029a7f;

+ private readonly Switch _device;

+ public void Initialize()

+ if (contentManager.TryGetFontTitle(name, out ulong fontTitle) && contentManager.TryGetFontFilename(name, out string fontFilename))

+ Nca nca = new Nca(_device.System.KeySet, ncaFileStream);

+ IFileSystem romfs = nca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);

+ throw new InvalidSystemResourceException("The sum of all fonts size exceed the shared memory size. " +

+ $"Please make sure that the fonts don't exceed {Horizon.FontSize} bytes in total. (actual size: {fontOffset} bytes).");

+ const int key = 0x49621806;

+ _storage.GetRef<int>(offset + 0) = (int)BFTTFMagic;

+

+ private static byte[] DecryptFont(Stream bfttfStream)

+ {

+ static uint KXor(uint data) => data ^ FontKey;

+

+ using (BinaryReader reader = new BinaryReader(bfttfStream))

+ using (MemoryStream ttfStream = new MemoryStream())

+ using (BinaryWriter output = new BinaryWriter(ttfStream))

+ {

+ if (KXor(reader.ReadUInt32()) != BFTTFMagic)

+ {

+ throw new InvalidDataException("Error: Input file is not in BFTTF format!");

+ }

+

+ bfttfStream.Position += 4;

+

+ for (int i = 0; i < (bfttfStream.Length - 8) / 4; i++)

+ {

+ output.Write(KXor(reader.ReadUInt32()));

+ }

+

+ return ttfStream.ToArray();

+ }

+ }

+} \ No newline at end of file

+namespace Ryujinx.HLE.HOS.Services.Sdb.Pl.Types

+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd

+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd

+using Ryujinx.Common.Utilities;

+ public bool IsFuncOrObject => Type == ElfSymbolType.SttFunc || Type == ElfSymbolType.SttObject;

+ public bool IsGlobalOrWeak => Binding == ElfSymbolBinding.StbGlobal || Binding == ElfSymbolBinding.StbWeak;

+} \ No newline at end of file

+} \ No newline at end of file

+ public uint RoOffset { get; }

+ public uint BssOffset { get; }

+ public uint RoSize { get; }

+ public uint BssSize { get; }

+ public int[] Capabilities { get; }

+ public bool UsesSecureMemory { get; }

+ public bool Is64Bit { get; }

+ public ulong ProgramId { get; }

+ public byte Priority { get; }

+ public int StackSize { get; }

+ public byte IdealCoreId { get; }

+ public int Version { get; }

+ public string Name { get; }

+ RoOffset = (uint)reader.Segments[1].MemoryOffset;

+ BssOffset = (uint)reader.Segments[3].MemoryOffset;

+ BssSize = (uint)reader.Segments[3].Size;

+ UsesSecureMemory = reader.UsesSecureMemory;

+ Is64Bit = reader.Is64Bit;

+ ProgramId = reader.ProgramId;

+ Priority = reader.Priority;

+ Version = reader.Version;

+ Name = reader.Name.ToString();

+ public uint RoOffset { get; }

+ public uint RoSize { get; }

+ public uint BssSize { get; }

+ Span<byte> IpsHeaderMagic = Encoding.ASCII.GetBytes("PATCH").AsSpan();

+ Span<byte> IpsTailMagic = Encoding.ASCII.GetBytes("EOF").AsSpan();

+ Span<byte> Ips32TailMagic = Encoding.ASCII.GetBytes("EEOF").AsSpan();

+ : buf[0] << 16 | buf[1] << 8 | buf[2];

+ private enum Token

+ {

+ Normal,

+ String,

+ EscapeChar,

+ Comment

+ }

+

+ private readonly StreamReader _reader;

+ public string BuildId { get; }

+

+ '"' => Token.Normal,

+ _ => Token.String

+ 'a' => '\a',

+ 'b' => '\b',

+ 'f' => '\f',

+ 'n' => '\n',

+ 'r' => '\r',

+ 't' => '\t',

+ 'v' => '\v',

+ _ => '?'

+ int low = ParseHexByte((byte)hexstr[i + 1]);

+

+ return int.TryParse(str.Substring(2), System.Globalization.NumberStyles.HexNumber, null, out value);

+ return int.TryParse(str, System.Globalization.NumberStyles.Integer, null, out value);

+ bool enabled = false;

+ if (!int.TryParse(tokens[0], System.Globalization.NumberStyles.HexNumber, null, out int offset))

+using Ryujinx.Common.Logging;

+ int patchSize = patch.Length;

+ patchSize = memory.Length - patchOffset; // Add warning?

+ MemoryConfiguration4GB = 0,

+ MemoryConfiguration6GB = 3,

+ MemoryConfiguration8GB = 5

+ MemoryConfiguration.MemoryConfiguration4GB => MemoryArrange.MemoryArrange4GB,

+ MemoryConfiguration.MemoryConfiguration6GB => MemoryArrange.MemoryArrange6GB,

+ MemoryConfiguration.MemoryConfiguration8GB => MemoryArrange.MemoryArrange8GB,

+ MemoryConfiguration.MemoryConfiguration8GB => MemorySize.MemorySize8GB,

+ MemoryConfiguration.MemoryConfiguration8GB => 8 * Gb,

+ private const int FrameTypeGame = 0;

+ private const int PercentTypeFifo = 0;

+ _averageFrameRate[frameType] = LinearInterpolate(_averageFrameRate[frameType], frameRate);

+ _framesRendered[frameType] = 0;

+ _averagePercent[percentType] = percent;

+ _percentTime[percentType] = 0;

+ private static double LinearInterpolate(double lhs, double rhs)

+ double currentTime = PerformanceCounter.ElapsedTicks * _ticksToSeconds;

+ double elapsedTime = currentTime - _percentLastEndTime[percentType];

+ _percentTime[percentType] += elapsedTime;

+ _percentStartTime[percentType] = 0;

+} \ No newline at end of file

+ inputString += "\0";

+ ulong position = context.Request.PtrBuff[index].Position;

+ ulong size = context.Request.PtrBuff[index].Size;

+ byte value = context.Memory.Read<byte>(position++);

+} \ No newline at end of file