1
0
Fork 0
mirror of https://github.com/Ryujinx/Ryujinx.git synced 2024-12-05 04:02:00 +00:00
Ryujinx/Ryujinx.HLE/HOS/Services/Vi/RootService/IApplicationDisplayService.cs

288 lines
9.4 KiB
C#
Raw Normal View History

Add a new JIT compiler for CPU code (#693) * Start of the ARMeilleure project * Refactoring around the old IRAdapter, now renamed to PreAllocator * Optimize the LowestBitSet method * Add CLZ support and fix CLS implementation * Add missing Equals and GetHashCode overrides on some structs, misc small tweaks * Implement the ByteSwap IR instruction, and some refactoring on the assembler * Implement the DivideUI IR instruction and fix 64-bits IDIV * Correct constant operand type on CSINC * Move division instructions implementation to InstEmitDiv * Fix destination type for the ConditionalSelect IR instruction * Implement UMULH and SMULH, with new IR instructions * Fix some issues with shift instructions * Fix constant types for BFM instructions * Fix up new tests using the new V128 struct * Update tests * Move DIV tests to a separate file * Add support for calls, and some instructions that depends on them * Start adding support for SIMD & FP types, along with some of the related ARM instructions * Fix some typos and the divide instruction with FP operands * Fix wrong method call on Clz_V * Implement ARM FP & SIMD move instructions, Saddlv_V, and misc. fixes * Implement SIMD logical instructions and more misc. fixes * Fix PSRAD x86 instruction encoding, TRN, UABD and UABDL implementations * Implement float conversion instruction, merge in LDj3SNuD fixes, and some other misc. fixes * Implement SIMD shift instruction and fix Dup_V * Add SCVTF and UCVTF (vector, fixed-point) variants to the opcode table * Fix check with tolerance on tester * Implement FP & SIMD comparison instructions, and some fixes * Update FCVT (Scalar) encoding on the table to support the Half-float variants * Support passing V128 structs, some cleanup on the register allocator, merge LDj3SNuD fixes * Use old memory access methods, made a start on SIMD memory insts support, some fixes * Fix float constant passed to functions, save and restore non-volatile XMM registers, other fixes * Fix arguments count with struct return values, other fixes * More instructions * Misc. fixes and integrate LDj3SNuD fixes * Update tests * Add a faster linear scan allocator, unwinding support on windows, and other changes * Update Ryujinx.HLE * Update Ryujinx.Graphics * Fix V128 return pointer passing, RCX is clobbered * Update Ryujinx.Tests * Update ITimeZoneService * Stop using GetFunctionPointer as that can't be called from native code, misc. fixes and tweaks * Use generic GetFunctionPointerForDelegate method and other tweaks * Some refactoring on the code generator, assert on invalid operations and use a separate enum for intrinsics * Remove some unused code on the assembler * Fix REX.W prefix regression on float conversion instructions, add some sort of profiler * Add hardware capability detection * Fix regression on Sha1h and revert Fcm** changes * Add SSE2-only paths on vector extract and insert, some refactoring on the pre-allocator * Fix silly mistake introduced on last commit on CpuId * Generate inline stack probes when the stack allocation is too large * Initial support for the System-V ABI * Support multiple destination operands * Fix SSE2 VectorInsert8 path, and other fixes * Change placement of XMM callee save and restore code to match other compilers * Rename Dest to Destination and Inst to Instruction * Fix a regression related to calls and the V128 type * Add an extra space on comments to match code style * Some refactoring * Fix vector insert FP32 SSE2 path * Port over the ARM32 instructions * Avoid memory protection races on JIT Cache * Another fix on VectorInsert FP32 (thanks to LDj3SNuD * Float operands don't need to use the same register when VEX is supported * Add a new register allocator, higher quality code for hot code (tier up), and other tweaks * Some nits, small improvements on the pre allocator * CpuThreadState is gone * Allow changing CPU emulators with a config entry * Add runtime identifiers on the ARMeilleure project * Allow switching between CPUs through a config entry (pt. 2) * Change win10-x64 to win-x64 on projects * Update the Ryujinx project to use ARMeilleure * Ensure that the selected register is valid on the hybrid allocator * Allow exiting on returns to 0 (should fix test regression) * Remove register assignments for most used variables on the hybrid allocator * Do not use fixed registers as spill temp * Add missing namespace and remove unneeded using * Address PR feedback * Fix types, etc * Enable AssumeStrictAbiCompliance by default * Ensure that Spill and Fill don't load or store any more than necessary
2019-08-08 19:56:22 +01:00
using ARMeilleure.Memory;
using Ryujinx.HLE.HOS.Ipc;
using Ryujinx.HLE.HOS.Kernel.Common;
using Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService;
using System;
2018-02-04 23:08:20 +00:00
using System.IO;
2018-07-24 22:38:44 +01:00
using System.Text;
2018-02-04 23:08:20 +00:00
using static Ryujinx.HLE.HOS.Services.SurfaceFlinger.Parcel;
2018-02-04 23:08:20 +00:00
namespace Ryujinx.HLE.HOS.Services.Vi.RootService
2018-02-04 23:08:20 +00:00
{
class IApplicationDisplayService : IpcService
2018-02-04 23:08:20 +00:00
{
private IdDictionary _displays;
public IApplicationDisplayService()
{
_displays = new IdDictionary();
}
[Command(100)]
// GetRelayService() -> object<nns::hosbinder::IHOSBinderDriver>
public ResultCode GetRelayService(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
MakeObject(context, new IHOSBinderDriver(
context.Device.System,
context.Device.Gpu.Renderer));
2018-02-04 23:08:20 +00:00
return ResultCode.Success;
2018-02-04 23:08:20 +00:00
}
[Command(101)]
// GetSystemDisplayService() -> object<nn::visrv::sf::ISystemDisplayService>
public ResultCode GetSystemDisplayService(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
MakeObject(context, new ISystemDisplayService(this));
2018-02-04 23:08:20 +00:00
return ResultCode.Success;
2018-02-04 23:08:20 +00:00
}
[Command(102)]
// GetManagerDisplayService() -> object<nn::visrv::sf::IManagerDisplayService>
public ResultCode GetManagerDisplayService(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
MakeObject(context, new IManagerDisplayService(this));
2018-02-04 23:08:20 +00:00
return ResultCode.Success;
2018-02-04 23:08:20 +00:00
}
[Command(103)] // 2.0.0+
// GetIndirectDisplayTransactionService() -> object<nns::hosbinder::IHOSBinderDriver>
public ResultCode GetIndirectDisplayTransactionService(ServiceCtx context)
{
MakeObject(context, new IHOSBinderDriver(
context.Device.System,
context.Device.Gpu.Renderer));
return ResultCode.Success;
}
[Command(1000)]
// ListDisplays() -> (u64, buffer<nn::vi::DisplayInfo, 6>)
public ResultCode ListDisplays(ServiceCtx context)
2018-07-24 22:38:44 +01:00
{
long recBuffPtr = context.Request.ReceiveBuff[0].Position;
2018-07-24 22:38:44 +01:00
MemoryHelper.FillWithZeros(context.Memory, recBuffPtr, 0x60);
2018-07-24 22:38:44 +01:00
// Add only the default display to buffer
context.Memory.WriteBytes(recBuffPtr, Encoding.ASCII.GetBytes("Default"));
context.Memory.WriteInt64(recBuffPtr + 0x40, 0x1L);
context.Memory.WriteInt64(recBuffPtr + 0x48, 0x1L);
context.Memory.WriteInt64(recBuffPtr + 0x50, 1920L);
context.Memory.WriteInt64(recBuffPtr + 0x58, 1080L);
2018-07-24 22:38:44 +01:00
context.ResponseData.Write(1L);
2018-07-24 22:38:44 +01:00
return ResultCode.Success;
2018-07-24 22:38:44 +01:00
}
[Command(1010)]
// OpenDisplay(nn::vi::DisplayName) -> u64
public ResultCode OpenDisplay(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
string name = GetDisplayName(context);
2018-02-04 23:08:20 +00:00
long displayId = _displays.Add(new Display(name));
2018-02-04 23:08:20 +00:00
context.ResponseData.Write(displayId);
2018-02-04 23:08:20 +00:00
return ResultCode.Success;
2018-02-04 23:08:20 +00:00
}
[Command(1020)]
// CloseDisplay(u64)
public ResultCode CloseDisplay(ServiceCtx context)
{
int displayId = context.RequestData.ReadInt32();
_displays.Delete(displayId);
return ResultCode.Success;
}
[Command(1102)]
// GetDisplayResolution(u64) -> (u64, u64)
public ResultCode GetDisplayResolution(ServiceCtx context)
2018-04-04 23:16:59 +01:00
{
long displayId = context.RequestData.ReadInt32();
2018-04-04 23:16:59 +01:00
context.ResponseData.Write(1280);
context.ResponseData.Write(720);
2018-04-04 23:16:59 +01:00
return ResultCode.Success;
2018-04-04 23:16:59 +01:00
}
[Command(2020)]
// OpenLayer(nn::vi::DisplayName, u64, nn::applet::AppletResourceUserId, pid) -> (u64, buffer<bytes, 6>)
public ResultCode OpenLayer(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
long layerId = context.RequestData.ReadInt64();
long userId = context.RequestData.ReadInt64();
2018-02-04 23:08:20 +00:00
long parcelPtr = context.Request.ReceiveBuff[0].Position;
2018-02-04 23:08:20 +00:00
byte[] parcel = MakeIGraphicsBufferProducer(parcelPtr);
2018-02-04 23:08:20 +00:00
context.Memory.WriteBytes(parcelPtr, parcel);
2018-02-04 23:08:20 +00:00
context.ResponseData.Write((long)parcel.Length);
2018-02-04 23:08:20 +00:00
return ResultCode.Success;
2018-02-04 23:08:20 +00:00
}
[Command(2021)]
// CloseLayer(u64)
public ResultCode CloseLayer(ServiceCtx context)
{
long layerId = context.RequestData.ReadInt64();
return ResultCode.Success;
}
[Command(2030)]
// CreateStrayLayer(u32, u64) -> (u64, u64, buffer<bytes, 6>)
public ResultCode CreateStrayLayer(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
long layerFlags = context.RequestData.ReadInt64();
long displayId = context.RequestData.ReadInt64();
2018-02-04 23:08:20 +00:00
long parcelPtr = context.Request.ReceiveBuff[0].Position;
2018-02-04 23:08:20 +00:00
Display disp = _displays.GetData<Display>((int)displayId);
2018-02-04 23:08:20 +00:00
byte[] parcel = MakeIGraphicsBufferProducer(parcelPtr);
2018-02-04 23:08:20 +00:00
context.Memory.WriteBytes(parcelPtr, parcel);
2018-02-04 23:08:20 +00:00
context.ResponseData.Write(0L);
context.ResponseData.Write((long)parcel.Length);
2018-02-04 23:08:20 +00:00
return ResultCode.Success;
2018-02-04 23:08:20 +00:00
}
[Command(2031)]
// DestroyStrayLayer(u64)
public ResultCode DestroyStrayLayer(ServiceCtx context)
{
return ResultCode.Success;
}
[Command(2101)]
// SetLayerScalingMode(u32, u64)
public ResultCode SetLayerScalingMode(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
int scalingMode = context.RequestData.ReadInt32();
long unknown = context.RequestData.ReadInt64();
2018-02-04 23:08:20 +00:00
return ResultCode.Success;
2018-02-04 23:08:20 +00:00
}
[Command(2102)] // 5.0.0+
// ConvertScalingMode(unknown) -> unknown
public ResultCode ConvertScalingMode(ServiceCtx context)
{
SourceScalingMode scalingMode = (SourceScalingMode)context.RequestData.ReadInt32();
DestinationScalingMode? convertedScalingMode = ConvertScalingMode(scalingMode);
if (!convertedScalingMode.HasValue)
{
// Scaling mode out of the range of valid values.
return ResultCode.InvalidArguments;
}
if (scalingMode != SourceScalingMode.ScaleToWindow &&
scalingMode != SourceScalingMode.PreserveAspectRatio)
{
// Invalid scaling mode specified.
return ResultCode.InvalidScalingMode;
}
context.ResponseData.Write((ulong)convertedScalingMode);
return ResultCode.Success;
}
private DestinationScalingMode? ConvertScalingMode(SourceScalingMode source)
{
switch (source)
{
case SourceScalingMode.None: return DestinationScalingMode.None;
case SourceScalingMode.Freeze: return DestinationScalingMode.Freeze;
case SourceScalingMode.ScaleAndCrop: return DestinationScalingMode.ScaleAndCrop;
case SourceScalingMode.ScaleToWindow: return DestinationScalingMode.ScaleToWindow;
case SourceScalingMode.PreserveAspectRatio: return DestinationScalingMode.PreserveAspectRatio;
}
return null;
}
[Command(5202)]
// GetDisplayVsyncEvent(u64) -> handle<copy>
public ResultCode GetDisplayVSyncEvent(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
string name = GetDisplayName(context);
2018-02-04 23:08:20 +00:00
if (context.Process.HandleTable.GenerateHandle(context.Device.System.VsyncEvent.ReadableEvent, out int handle) != KernelResult.Success)
{
throw new InvalidOperationException("Out of handles!");
}
2018-02-04 23:08:20 +00:00
context.Response.HandleDesc = IpcHandleDesc.MakeCopy(handle);
2018-02-04 23:08:20 +00:00
return ResultCode.Success;
2018-02-04 23:08:20 +00:00
}
private byte[] MakeIGraphicsBufferProducer(long basePtr)
2018-02-04 23:08:20 +00:00
{
long id = 0x20;
long cookiePtr = 0L;
2018-02-04 23:08:20 +00:00
using (MemoryStream ms = new MemoryStream())
2018-02-04 23:08:20 +00:00
{
BinaryWriter writer = new BinaryWriter(ms);
2018-02-04 23:08:20 +00:00
// flat_binder_object (size is 0x28)
writer.Write(2); //Type (BINDER_TYPE_WEAK_BINDER)
writer.Write(0); //Flags
writer.Write((int)(id >> 0));
writer.Write((int)(id >> 32));
writer.Write((int)(cookiePtr >> 0));
writer.Write((int)(cookiePtr >> 32));
writer.Write((byte)'d');
writer.Write((byte)'i');
writer.Write((byte)'s');
writer.Write((byte)'p');
writer.Write((byte)'d');
writer.Write((byte)'r');
writer.Write((byte)'v');
writer.Write((byte)'\0');
writer.Write(0L); //Pad
return MakeParcel(ms.ToArray(), new byte[] { 0, 0, 0, 0 });
2018-02-04 23:08:20 +00:00
}
}
private string GetDisplayName(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
string name = string.Empty;
2018-02-04 23:08:20 +00:00
for (int index = 0; index < 8 &&
context.RequestData.BaseStream.Position <
context.RequestData.BaseStream.Length; index++)
2018-02-04 23:08:20 +00:00
{
byte chr = context.RequestData.ReadByte();
2018-02-04 23:08:20 +00:00
if (chr >= 0x20 && chr < 0x7f)
2018-02-04 23:08:20 +00:00
{
name += (char)chr;
2018-02-04 23:08:20 +00:00
}
}
return name;
2018-02-04 23:08:20 +00:00
}
}
}