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;
|
2018-08-17 00:47:36 +01:00
|
|
|
using Ryujinx.HLE.HOS.Ipc;
|
2018-12-18 05:33:36 +00:00
|
|
|
using Ryujinx.HLE.HOS.Kernel.Common;
|
2018-09-23 19:11:46 +01:00
|
|
|
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
|
|
|
|
2018-08-17 00:47:36 +01:00
|
|
|
using static Ryujinx.HLE.HOS.Services.Android.Parcel;
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-08-17 00:47:36 +01:00
|
|
|
namespace Ryujinx.HLE.HOS.Services.Vi
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-03-19 18:58:46 +00:00
|
|
|
class IApplicationDisplayService : IpcService
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
private IdDictionary _displays;
|
2018-03-12 04:04:52 +00:00
|
|
|
|
2018-02-10 00:14:55 +00:00
|
|
|
public IApplicationDisplayService()
|
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
_displays = new IdDictionary();
|
2018-02-10 00:14:55 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(100)]
|
|
|
|
// GetRelayService() -> object<nns::hosbinder::IHOSBinderDriver>
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode GetRelayService(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2019-07-12 02:13:43 +01:00
|
|
|
MakeObject(context, new IHOSBinderDriver(
|
2018-12-06 11:16:24 +00:00
|
|
|
context.Device.System,
|
|
|
|
context.Device.Gpu.Renderer));
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(101)]
|
|
|
|
// GetSystemDisplayService() -> object<nn::visrv::sf::ISystemDisplayService>
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode GetSystemDisplayService(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2019-01-05 21:26:16 +00:00
|
|
|
MakeObject(context, new ISystemDisplayService(this));
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(102)]
|
|
|
|
// GetManagerDisplayService() -> object<nn::visrv::sf::IManagerDisplayService>
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode GetManagerDisplayService(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2019-04-25 23:57:18 +01:00
|
|
|
MakeObject(context, new IManagerDisplayService(this));
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(103)] // 2.0.0+
|
|
|
|
// GetIndirectDisplayTransactionService() -> object<nns::hosbinder::IHOSBinderDriver>
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode GetIndirectDisplayTransactionService(ServiceCtx context)
|
2018-02-06 23:28:32 +00:00
|
|
|
{
|
2019-07-12 02:13:43 +01:00
|
|
|
MakeObject(context, new IHOSBinderDriver(
|
2018-12-06 11:16:24 +00:00
|
|
|
context.Device.System,
|
|
|
|
context.Device.Gpu.Renderer));
|
2018-02-06 23:28:32 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-06 23:28:32 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(1000)]
|
|
|
|
// ListDisplays() -> (u64, buffer<nn::vi::DisplayInfo, 6>)
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode ListDisplays(ServiceCtx context)
|
2018-07-24 22:38:44 +01:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
long recBuffPtr = context.Request.ReceiveBuff[0].Position;
|
2018-07-24 22:38:44 +01:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
MemoryHelper.FillWithZeros(context.Memory, recBuffPtr, 0x60);
|
2018-07-24 22:38:44 +01:00
|
|
|
|
2019-07-02 03:39:22 +01:00
|
|
|
// Add only the default display to buffer
|
2018-12-06 11:16:24 +00:00
|
|
|
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
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
context.ResponseData.Write(1L);
|
2018-07-24 22:38:44 +01:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-07-24 22:38:44 +01:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(1010)]
|
|
|
|
// OpenDisplay(nn::vi::DisplayName) -> u64
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode OpenDisplay(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
string name = GetDisplayName(context);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
long displayId = _displays.Add(new Display(name));
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
context.ResponseData.Write(displayId);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(1020)]
|
|
|
|
// CloseDisplay(u64)
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode CloseDisplay(ServiceCtx context)
|
2018-03-06 13:25:26 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
int displayId = context.RequestData.ReadInt32();
|
2018-03-06 13:25:26 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
_displays.Delete(displayId);
|
2018-03-06 13:25:26 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-03-06 13:25:26 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(1102)]
|
|
|
|
// GetDisplayResolution(u64) -> (u64, u64)
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode GetDisplayResolution(ServiceCtx context)
|
2018-04-04 23:16:59 +01:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
long displayId = context.RequestData.ReadInt32();
|
2018-04-04 23:16:59 +01:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
context.ResponseData.Write(1280);
|
|
|
|
context.ResponseData.Write(720);
|
2018-04-04 23:16:59 +01:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-04-04 23:16:59 +01:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(2020)]
|
|
|
|
// OpenLayer(nn::vi::DisplayName, u64, nn::applet::AppletResourceUserId, pid) -> (u64, buffer<bytes, 6>)
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode OpenLayer(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
long layerId = context.RequestData.ReadInt64();
|
|
|
|
long userId = context.RequestData.ReadInt64();
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
long parcelPtr = context.Request.ReceiveBuff[0].Position;
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
byte[] parcel = MakeIGraphicsBufferProducer(parcelPtr);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
context.Memory.WriteBytes(parcelPtr, parcel);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
context.ResponseData.Write((long)parcel.Length);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(2021)]
|
|
|
|
// CloseLayer(u64)
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode CloseLayer(ServiceCtx context)
|
2018-03-06 20:27:50 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
long layerId = context.RequestData.ReadInt64();
|
2018-03-12 04:04:52 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-03-06 20:27:50 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(2030)]
|
|
|
|
// CreateStrayLayer(u32, u64) -> (u64, u64, buffer<bytes, 6>)
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode CreateStrayLayer(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
long layerFlags = context.RequestData.ReadInt64();
|
|
|
|
long displayId = context.RequestData.ReadInt64();
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
long parcelPtr = context.Request.ReceiveBuff[0].Position;
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
Display disp = _displays.GetData<Display>((int)displayId);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
byte[] parcel = MakeIGraphicsBufferProducer(parcelPtr);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
context.Memory.WriteBytes(parcelPtr, parcel);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
context.ResponseData.Write(0L);
|
|
|
|
context.ResponseData.Write((long)parcel.Length);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(2031)]
|
|
|
|
// DestroyStrayLayer(u64)
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode DestroyStrayLayer(ServiceCtx context)
|
2018-03-12 04:04:52 +00:00
|
|
|
{
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-03-12 04:04:52 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(2101)]
|
|
|
|
// SetLayerScalingMode(u32, u64)
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode SetLayerScalingMode(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
int scalingMode = context.RequestData.ReadInt32();
|
|
|
|
long unknown = context.RequestData.ReadInt64();
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(2102)] // 5.0.0+
|
|
|
|
// ConvertScalingMode(unknown) -> unknown
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode ConvertScalingMode(ServiceCtx context)
|
2019-02-15 04:47:40 +00:00
|
|
|
{
|
2019-02-19 00:12:53 +00:00
|
|
|
SrcScalingMode scalingMode = (SrcScalingMode)context.RequestData.ReadInt32();
|
2019-02-15 04:47:40 +00:00
|
|
|
|
2019-02-19 00:12:53 +00:00
|
|
|
DstScalingMode? convertedScalingMode = ConvertScalingMode(scalingMode);
|
|
|
|
|
|
|
|
if (!convertedScalingMode.HasValue)
|
2019-02-15 04:47:40 +00:00
|
|
|
{
|
2019-07-02 03:39:22 +01:00
|
|
|
// Scaling mode out of the range of valid values.
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.InvalidArguments;
|
2019-02-15 04:47:40 +00:00
|
|
|
}
|
|
|
|
|
2019-02-19 00:12:53 +00:00
|
|
|
if (scalingMode != SrcScalingMode.ScaleToWindow &&
|
|
|
|
scalingMode != SrcScalingMode.PreserveAspectRatio)
|
|
|
|
{
|
2019-07-02 03:39:22 +01:00
|
|
|
// Invalid scaling mode specified.
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.InvalidScalingMode;
|
2019-02-19 00:12:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
context.ResponseData.Write((ulong)convertedScalingMode);
|
2019-02-15 04:47:40 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2019-02-15 04:47:40 +00:00
|
|
|
}
|
|
|
|
|
2019-02-19 00:12:53 +00:00
|
|
|
private DstScalingMode? ConvertScalingMode(SrcScalingMode source)
|
2019-02-15 04:47:40 +00:00
|
|
|
{
|
2019-02-19 00:12:53 +00:00
|
|
|
switch (source)
|
2019-02-15 04:47:40 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2019-07-12 02:13:43 +01:00
|
|
|
[Command(5202)]
|
|
|
|
// GetDisplayVsyncEvent(u64) -> handle<copy>
|
2019-07-14 20:04:38 +01:00
|
|
|
public ResultCode GetDisplayVSyncEvent(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
string name = GetDisplayName(context);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
if (context.Process.HandleTable.GenerateHandle(context.Device.System.VsyncEvent.ReadableEvent, out int handle) != KernelResult.Success)
|
2018-09-23 19:11:46 +01:00
|
|
|
{
|
|
|
|
throw new InvalidOperationException("Out of handles!");
|
|
|
|
}
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
context.Response.HandleDesc = IpcHandleDesc.MakeCopy(handle);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-14 20:04:38 +01:00
|
|
|
return ResultCode.Success;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
private byte[] MakeIGraphicsBufferProducer(long basePtr)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
long id = 0x20;
|
|
|
|
long cookiePtr = 0L;
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
using (MemoryStream ms = new MemoryStream())
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
BinaryWriter writer = new BinaryWriter(ms);
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2019-07-02 03:39:22 +01:00
|
|
|
// flat_binder_object (size is 0x28)
|
2018-12-06 11:16:24 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
private string GetDisplayName(ServiceCtx context)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
string name = string.Empty;
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +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
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
byte chr = context.RequestData.ReadByte();
|
2018-02-04 23:08:20 +00:00
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
if (chr >= 0x20 && chr < 0x7f)
|
2018-02-04 23:08:20 +00:00
|
|
|
{
|
2018-12-06 11:16:24 +00:00
|
|
|
name += (char)chr;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-06 11:16:24 +00:00
|
|
|
return name;
|
2018-02-04 23:08:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|