0
0
Fork 0
This repository has been archived on 2024-10-12. You can view files and clone it, but cannot push or open issues or pull requests.
ryujinx-final/Ryujinx.HLE/HOS/Services/Vi/IApplicationDisplayService.cs

282 lines
8.9 KiB
C#
Raw Normal View History

2018-07-24 21:38:44 +00:00
using ChocolArm64.Memory;
using Ryujinx.HLE.HOS.Ipc;
using Ryujinx.HLE.HOS.Kernel.Common;
using System.Collections.Generic;
using System;
2018-02-04 23:08:20 +00:00
using System.IO;
2018-07-24 21:38:44 +00:00
using System.Text;
2018-02-04 23:08:20 +00:00
using static Ryujinx.HLE.HOS.ErrorCode;
using static Ryujinx.HLE.HOS.Services.Android.Parcel;
2018-02-04 23:08:20 +00:00
namespace Ryujinx.HLE.HOS.Services.Vi
2018-02-04 23:08:20 +00:00
{
class IApplicationDisplayService : IpcService
2018-02-04 23:08:20 +00:00
{
private Dictionary<int, ServiceProcessRequest> _commands;
public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => _commands;
private IdDictionary _displays;
public IApplicationDisplayService()
{
_commands = new Dictionary<int, ServiceProcessRequest>
{
2018-04-24 18:57:39 +00:00
{ 100, GetRelayService },
{ 101, GetSystemDisplayService },
{ 102, GetManagerDisplayService },
{ 103, GetIndirectDisplayTransactionService },
2018-07-24 21:38:44 +00:00
{ 1000, ListDisplays },
{ 1010, OpenDisplay },
{ 1020, CloseDisplay },
2018-04-04 22:16:59 +00:00
{ 1102, GetDisplayResolution },
{ 2020, OpenLayer },
{ 2021, CloseLayer },
{ 2030, CreateStrayLayer },
{ 2031, DestroyStrayLayer },
{ 2101, SetLayerScalingMode },
{ 2102, ConvertScalingMode },
{ 5202, GetDisplayVSyncEvent }
};
_displays = new IdDictionary();
}
public long 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 0;
}
public long 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 0;
}
public long GetManagerDisplayService(ServiceCtx context)
2018-02-04 23:08:20 +00:00
{
MakeObject(context, new IManagerDisplayService());
2018-02-04 23:08:20 +00:00
return 0;
}
public long GetIndirectDisplayTransactionService(ServiceCtx context)
{
MakeObject(context, new IhosBinderDriver(
context.Device.System,
context.Device.Gpu.Renderer));
return 0;
}
public long ListDisplays(ServiceCtx context)
2018-07-24 21:38:44 +00:00
{
long recBuffPtr = context.Request.ReceiveBuff[0].Position;
2018-07-24 21:38:44 +00:00
MemoryHelper.FillWithZeros(context.Memory, recBuffPtr, 0x60);
2018-07-24 21:38:44 +00: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 21:38:44 +00:00
context.ResponseData.Write(1L);
2018-07-24 21:38:44 +00:00
return 0;
}
public long 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 0;
}
public long CloseDisplay(ServiceCtx context)
{
int displayId = context.RequestData.ReadInt32();
_displays.Delete(displayId);
return 0;
}
public long GetDisplayResolution(ServiceCtx context)
2018-04-04 22:16:59 +00:00
{
long displayId = context.RequestData.ReadInt32();
2018-04-04 22:16:59 +00:00
context.ResponseData.Write(1280);
context.ResponseData.Write(720);
2018-04-04 22:16:59 +00:00
return 0;
}
public long 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 0;
}
public long CloseLayer(ServiceCtx context)
{
long layerId = context.RequestData.ReadInt64();
return 0;
}
public long 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 0;
}
public long DestroyStrayLayer(ServiceCtx context)
{
return 0;
}
public long 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 0;
}
public long ConvertScalingMode(ServiceCtx context)
{
SrcScalingMode scalingMode = (SrcScalingMode)context.RequestData.ReadInt32();
DstScalingMode? convertedScalingMode = ConvertScalingMode(scalingMode);
if (!convertedScalingMode.HasValue)
{
//Scaling mode out of the range of valid values.
return MakeError(ErrorModule.Vi, 1);
}
if (scalingMode != SrcScalingMode.ScaleToWindow &&
scalingMode != SrcScalingMode.PreserveAspectRatio)
{
//Invalid scaling mode specified.
return MakeError(ErrorModule.Vi, 6);
}
context.ResponseData.Write((ulong)convertedScalingMode);
return 0;
}
private DstScalingMode? ConvertScalingMode(SrcScalingMode source)
{
switch (source)
{
case SrcScalingMode.None: return DstScalingMode.None;
case SrcScalingMode.Freeze: return DstScalingMode.Freeze;
case SrcScalingMode.ScaleAndCrop: return DstScalingMode.ScaleAndCrop;
case SrcScalingMode.ScaleToWindow: return DstScalingMode.ScaleToWindow;
case SrcScalingMode.PreserveAspectRatio: return DstScalingMode.PreserveAspectRatio;
}
return null;
}
public long 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 0;
}
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
}
}
}