public static void stereoToMono(int dstAddrReg, int srcAddrReg, int samplesReg)
{
int samples = getRegisterValue(samplesReg);
int srcAddr = getRegisterValue(srcAddrReg);
int dstAddr = getRegisterValue(dstAddrReg);
int srcAddrAlignment = srcAddr & 0x2;
IMemoryReader memoryReader = MemoryReader.getMemoryReader(srcAddr - srcAddrAlignment, samples << 2, 4);
IMemoryWriter memoryWriter = MemoryWriter.getMemoryWriter(dstAddr, samples << 1, 2);
if (srcAddrAlignment == 0)
{
// Taking left samples as mono samples
for (int i = 0; i < samples; i++)
{
int sample = memoryReader.readNext();
memoryWriter.writeNext(sample);
}
}
else
{
// Taking right samples as mono samples
for (int i = 0; i < samples; i++)
{
int sample = memoryReader.readNext();
sample = (int)((uint)sample >> 16);
memoryWriter.writeNext(sample);
}
}
memoryWriter.flush();
}
public static void adjustVolume(int dstAddrReg, int srcAddrReg, int samplesReg, int volReg)
{
float vol = getFRegisterValue(volReg);
if (vol != 1f)
{
int samples = getRegisterValue(samplesReg);
int srcAddr = getRegisterValue(srcAddrReg);
int dstAddr = getRegisterValue(dstAddrReg);
IMemoryReader memoryReader = MemoryReader.getMemoryReader(srcAddr, samples << 1, 2);
IMemoryWriter memoryWriter = MemoryWriter.getMemoryWriter(dstAddr, samples << 1, 2);
if (vol == .5f)
{
for (int i = 0; i < samples; i++)
{
int sample = memoryReader.readNext();
sample = (sample << 16) >> 17;
memoryWriter.writeNext(sample);
}
}
else
{
for (int i = 0; i < samples; i++)
{
int sample = (short)memoryReader.readNext();
sample = (int)(sample * vol);
memoryWriter.writeNext(sample);
}
}
memoryWriter.flush();
}
}
public static void multMat4x4ByVec4(int matReg, int matOffset, int vecReg, int vecOffset, int resultReg, int resultOffset)
{
int mat = getRegisterValue(matReg) + matOffset;
int vec = getRegisterValue(vecReg) + vecOffset;
int result = getRegisterValue(resultReg) + resultOffset;
IMemoryReader matReader = MemoryReader.getMemoryReader(mat, 64, 4);
IMemoryReader vecReader = MemoryReader.getMemoryReader(vec, 16, 4);
IMemoryWriter resultWriter = MemoryWriter.getMemoryWriter(result, 16, 4);
float vec0 = Float.intBitsToFloat(vecReader.readNext());
float vec1 = Float.intBitsToFloat(vecReader.readNext());
float vec2 = Float.intBitsToFloat(vecReader.readNext());
float vec3 = Float.intBitsToFloat(vecReader.readNext());
for (int i = 0; i < 4; i++)
{
float mat0 = Float.intBitsToFloat(matReader.readNext());
float mat1 = Float.intBitsToFloat(matReader.readNext());
float mat2 = Float.intBitsToFloat(matReader.readNext());
float mat3 = Float.intBitsToFloat(matReader.readNext());
float res = vec0 * mat0 + vec1 * mat1 + vec2 * mat2 + vec3 * mat3;
resultWriter.writeNext(Float.floatToRawIntBits(res));
}
resultWriter.flush();
}
public static void updateCommands(int @base, int startReg, int endReg, int offsetReg, int stepReg)
{
Memory mem = Memory;
int start = getRegisterValue(startReg);
int end = getRegisterValue(endReg);
int offset = getRegisterValue(offsetReg);
int step = getRegisterValue(stepReg);
int skip = (step - 4) >> 2;
IMemoryReader baseReader = MemoryReader.getMemoryReader(getRegisterValue(@base), (end - start) << 4, 4);
for (int i = start; i < end; i++)
{
baseReader.skip(1);
int addr = baseReader.readNext();
int count = baseReader.readNext();
int dest = baseReader.readNext();
IMemoryReader addrReader = MemoryReader.getMemoryReader(addr, count << 2, 4);
IMemoryWriter destWriter = MemoryWriter.getMemoryWriter(dest + offset, count * step, 4);
for (int j = 0; j < count; j++)
{
int src = addrReader.readNext();
destWriter.writeNext(mem.read32(src));
destWriter.skip(skip);
}
destWriter.flush();
}
}
protected internal static int doAudioOutput(SoundChannel channel, int pvoid_buf)
{
int ret = -1;
if (channel.Reserved)
{
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("doAudioOutput({0}, 0x{1:X8})", channel.ToString(), pvoid_buf));
}
int bytesPerSample = channel.FormatStereo ? 4 : 2;
int nbytes = bytesPerSample * channel.SampleLength;
sbyte[] data = new sbyte[nbytes];
IMemoryReader memoryReader = MemoryReader.getMemoryReader(pvoid_buf, nbytes, 2);
if (channel.FormatMono)
{
int volume = Audio.getVolume(channel.LeftVolume);
for (int i = 0; i < nbytes; i += 2)
{
short sample = (short)memoryReader.readNext();
sample = SoundChannel.adjustSample(sample, volume);
SoundChannel.storeSample(sample, data, i);
}
}
else
{
int leftVolume = Audio.getVolume(channel.LeftVolume);
int rightVolume = Audio.getVolume(channel.RightVolume);
for (int i = 0; i < nbytes; i += 4)
{
short lsample = (short)memoryReader.readNext();
short rsample = (short)memoryReader.readNext();
lsample = SoundChannel.adjustSample(lsample, leftVolume);
rsample = SoundChannel.adjustSample(rsample, rightVolume);
SoundChannel.storeSample(lsample, data, i);
SoundChannel.storeSample(rsample, data, i + 2);
}
}
Modules.sceAudioModule.audioData = data;
channel.play(data);
ret = channel.SampleLength;
}
else
{
Console.WriteLine("doAudioOutput: channel " + channel.Index + " not reserved");
}
return(ret);
}
public virtual int sceAdler32(int adler, TPointer data, int Length)
{
if (log.TraceEnabled)
{
log.trace(string.Format("sceAdler32 data:{0}", Utilities.getMemoryDump(data.Address, Length)));
}
sbyte[] b = new sbyte[Length];
IMemoryReader memoryReader = MemoryReader.getMemoryReader(data.Address, Length, 1);
for (int i = 0; i < Length; i++)
{
b[i] = (sbyte)memoryReader.readNext();
}
adler32.reset();
adler32.update(adler);
adler32.update(b);
int result = (int)adler32.Value;
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("sceAdler32 returning 0x{0:X8}", result));
}
return(result);
}
/// <summary>
/// Mix stereo samples in memory: add one stereo sample stream to another
/// stereo sample stream.
/// </summary>
/// <param name="inAddr"> the start address of the input stereo sample stream </param>
/// <param name="inOutAddr"> the start address of the stereo sample being updated </param>
/// <param name="samples"> the number of stereo samples </param>
public static void mixStereoInMemory(int inAddr, int inOutAddr, int samples)
{
int Length = samples << 2;
IMemoryReader inReader = MemoryReader.getMemoryReader(inAddr, Length, 4);
IMemoryReader inOutReader = MemoryReader.getMemoryReader(inOutAddr, Length, 4);
IMemoryWriter inOutWriter = MemoryWriter.getMemoryWriter(inOutAddr, Length, 4);
for (int i = 0; i < samples; i++)
{
int inStereoValue = inReader.readNext();
if (inStereoValue == 0)
{
// InOut unchanged for this sample
inOutReader.skip(1);
inOutWriter.skip(1);
}
else
{
int inOutStereoValue = inOutReader.readNext();
inOutStereoValue = mixStereo(inStereoValue, inOutStereoValue);
inOutWriter.writeNext(inOutStereoValue);
}
}
inOutWriter.flush();
}
public static void call()
{
int src1Addr = GprA0;
int src2Addr = GprA1;
int n = GprA2;
if (log.TraceEnabled)
{
log.trace(string.Format("memcmp src1={0}, src2={1}, n=0x{2:X}", Utilities.getMemoryDump(src1Addr, n), Utilities.getMemoryDump(src2Addr, n), n));
}
IMemoryReader memoryReader1 = MemoryReader.getMemoryReader(src1Addr, n, 1);
IMemoryReader memoryReader2 = MemoryReader.getMemoryReader(src2Addr, n, 1);
for (int i = 0; i < n; i++)
{
int c1 = memoryReader1.readNext();
int c2 = memoryReader2.readNext();
if (c1 != c2)
{
GprV0 = c1 - c2;
return;
}
}
GprV0 = 0;
}
public static void call()
{
int srcAddr = GprA0;
int c1 = GprA1 & 0xFF;
int result = 0;
IMemoryReader memoryReader = MemoryReader.getMemoryReader(srcAddr, 1);
if (memoryReader != null)
{
for (int i = 0; true; i++)
{
int c2 = memoryReader.readNext();
if (c1 == c2)
{
// Character found
result = srcAddr + i;
}
else if (c2 == 0)
{
// End of Src string found
break;
}
}
}
GprV0 = result;
}
public static void callCopyWithLength(int errorCode1, int errorCode2)
{
int srcAddr = GprA0;
int dstAddr = GprA1;
int Length = GprA2;
int lengthSrc = getStrlen(srcAddr);
if (lengthSrc > Length)
{
GprV0 = (errorCode1 << 16) | errorCode2;
return;
}
IMemoryReader memoryReader = MemoryReader.getMemoryReader(srcAddr, Length, 1);
IMemoryWriter memoryWriter = MemoryWriter.getMemoryWriter(dstAddr, Length, 1);
for (int i = 0; i < lengthSrc; i++)
{
int c = toUpperCase[memoryReader.readNext()];
memoryWriter.writeNext(c);
}
memoryWriter.writeNext(0);
memoryWriter.flush();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void write(java.io.OutputStream out) throws java.io.IOException
public virtual void write(System.IO.Stream @out)
{
DataOutputStream data = new DataOutputStream(@out);
data.writeInt(packetSize);
data.writeInt(address);
data.writeInt(Length);
if (buffer is ByteBuffer)
{
WritableByteChannel channel = Channels.newChannel(@out);
channel.write((ByteBuffer)buffer);
}
else
{
IMemoryReader reader = MemoryReader.getMemoryReader(address, Length, 1);
for (int i = 0; i < Length; i++)
{
data.writeByte(reader.readNext());
}
}
VideoEngine.log_Renamed.info(string.Format("Saved memory {0:x8} - {1:x8} (len {2:x8})", address, address + Length, Length));
//VideoEngine.Console.WriteLine("CaptureRAM write " + ((3 * 4) + Length));
//data.flush();
//out.flush();
}
public virtual int sceSha256Digest(TPointer data, int Length, TPointer digest)
{
if (log.TraceEnabled)
{
log.trace(string.Format("sceSha256Digest data:{0}", Utilities.getMemoryDump(data.Address, Length)));
}
// Read in the source data.
sbyte[] b = new sbyte[Length];
IMemoryReader memoryReader = MemoryReader.getMemoryReader(data.Address, Length, 1);
for (int i = 0; i < Length; i++)
{
b[i] = (sbyte)memoryReader.readNext();
}
// Calculate SHA-256.
SHA256 sha256 = new SHA256();
sbyte[] d = sha256.doSHA256(b, Length);
// Write back the resulting digest.
IMemoryWriter memoryWriter = MemoryWriter.getMemoryWriter(digest.Address, 0x20, 1);
for (int i = 0; i < 0x20; i++)
{
memoryWriter.writeNext((sbyte)d[i]);
}
return(0);
}
public static void call()
{
int src1Addr = GprA0;
int src2Addr = GprA1;
int n = GprA2;
if (n > 0)
{
IMemoryReader memoryReader1 = MemoryReader.getMemoryReader(src1Addr, n, 1);
IMemoryReader memoryReader2 = MemoryReader.getMemoryReader(src2Addr, n, 1);
if (memoryReader1 != null && memoryReader2 != null)
{
for (int i = 0; i < n; i++)
{
int c1 = toLowerCase[memoryReader1.readNext()];
int c2 = toLowerCase[memoryReader2.readNext()];
if (c1 != c2)
{
GprV0 = c1 - c2;
return;
}
else if (c1 == 0)
{
// c1 == 0 and c2 == 0
break;
}
}
}
}
GprV0 = 0;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected void write(pspsharp.state.StateOutputStream stream, int address, int Length) throws java.io.IOException
protected internal virtual void write(StateOutputStream stream, int address, int Length)
{
IMemoryReader memoryReader = MemoryReader.getMemoryReader(this, address, Length, 4);
for (int i = 0; i < Length; i += 4)
{
stream.writeInt(memoryReader.readNext());
}
}
public override int ioDevctl(string deviceName, int command, TPointer inputPointer, int inputLength, TPointer outputPointer, int outputLength)
{
switch (command)
{
case EMULATOR_DEVCTL_GET_HAS_DISPLAY:
if (!outputPointer.AddressGood || outputLength < 4)
{
return(base.ioDevctl(deviceName, command, inputPointer, inputLength, outputPointer, outputLength));
}
outputPointer.setValue32(Screen.hasScreen());
break;
case EMULATOR_DEVCTL_SEND_OUTPUT:
sbyte[] input = new sbyte[inputLength];
IMemoryReader memoryReader = MemoryReader.getMemoryReader(inputPointer.Address, inputLength, 1);
for (int i = 0; i < inputLength; i++)
{
input[i] = (sbyte)memoryReader.readNext();
}
string outputString = StringHelper.NewString(input);
//if (log.DebugEnabled)
{
Console.WriteLine(outputString);
}
AutoTestsOutput.appendString(outputString);
break;
case EMULATOR_DEVCTL_IS_EMULATOR:
break;
case EMULATOR_DEVCTL_EMIT_SCREENSHOT:
BufferInfo fb = Modules.sceDisplayModule.BufferInfoFb;
Buffer buffer = Memory.Instance.getBuffer(fb.topAddr, fb.bufferWidth * fb.height * getPixelFormatBytes(fb.pixelFormat));
CaptureImage captureImage = new CaptureImage(fb.topAddr, 0, buffer, fb.width, fb.height, fb.bufferWidth, fb.pixelFormat, false, 0, false, true, null);
captureImage.FileName = ScreenshotFileName;
captureImage.FileFormat = ScreenshotFormat;
try
{
captureImage.write();
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("Screenshot 0x{0:X8}-0x{1:X8} saved under '{2}'", fb.topAddr, fb.bottomAddr, captureImage.FileName));
}
}
catch (IOException e)
{
Console.WriteLine("Emit Screenshot", e);
}
break;
default:
// Unknown command
return(base.ioDevctl(deviceName, command, inputPointer, inputLength, outputPointer, outputLength));
}
return(0);
}
/// <summary>
/// Generate a hashCode on a memory range using a rather simple but fast method.
/// The hashCode will be independent of the address, i.e. the same hashCode will
/// be generated for the same data at different memory addresses.
/// </summary>
/// <param name="hashCode"> current hashCode value </param>
/// <param name="memoryReader"> the memory reader for the values to be hashed </param>
/// <param name="lengthInBytes"> Length of the memory range </param>
/// <returns> updated hashCode value </returns>
public static int getHashCodeFloatingMemory(int hashCode, IMemoryReader memoryReader, int lengthInBytes)
{
for (int i = 0; i < lengthInBytes; i += 4)
{
int value = memoryReader.readNext();
hashCode ^= value + i;
hashCode += i;
}
return(hashCode);
}
private static int sceGuSetMatrix4x4(IMemoryWriter listWriter, IMemoryReader matrixReader, int startCmd, int matrixCmd, int index)
{
listWriter.writeNext((startCmd << 24) + index);
int cmd = matrixCmd << 24;
for (int i = 0; i < 16; i++)
{
listWriter.writeNext(cmd | ((int)((uint)matrixReader.readNext() >> 8)));
}
return(68);
}
protected internal static sbyte[] getMemoryBytes(int address, int size)
{
sbyte[] bytes = new sbyte[size];
IMemoryReader memoryReader = MemoryReader.getMemoryReader(address, size, 1);
for (int i = 0; i < size; i++)
{
bytes[i] = (sbyte)memoryReader.readNext();
}
return(bytes);
}
/// <summary>
/// Synthesizing audio function with mix. </summary>
/// <param name="addr"> Input and output address for the PCM data (must be 64-byte aligned). </param>
/// <param name="samples"> Number of samples returned. </param>
/// <param name="leftVol"> the volume of the left channel for modulating the input PCM data.
/// This volume is not affecting the currently played samples. </param>
/// <param name="rightVol"> the volume of the right channel for modulating the input PCM data.
/// This volume is not affecting the currently played samples. </param>
public virtual void synthesizeWithMix(int addr, int samples, int leftVol, int rightVol)
{
int[] mixedSamples = new int[samples * 2];
// Read the input buffer into mixedSamples.
// Check first for simple cases...
if (leftVol == 0 && rightVol == 0)
{
// Do not mix with the input buffer
Arrays.Fill(mixedSamples, 0);
}
else if (leftVol == MAX_VOLUME && rightVol == MAX_VOLUME)
{
// Mix with the input buffer with no volume change
int lengthInBytes = mixedSamples.Length * 2;
IMemoryReader memoryReader = MemoryReader.getMemoryReader(addr, lengthInBytes, 2);
for (int i = 0; i < mixedSamples.Length; i++)
{
mixedSamples[i] = (short)memoryReader.readNext();
}
}
else
{
// Mix with the input buffer with a volume adjustment
int lengthInBytes = mixedSamples.Length * 2;
IMemoryReader memoryReader = MemoryReader.getMemoryReader(addr, lengthInBytes, 2);
for (int i = 0; i < samples; i++)
{
short sampleLeft = (short)memoryReader.readNext();
short sampleRight = (short)memoryReader.readNext();
sampleLeft = SoundChannel.adjustSample(sampleLeft, leftVol);
sampleRight = SoundChannel.adjustSample(sampleRight, rightVol);
mixedSamples[i * 2] = sampleLeft;
mixedSamples[i * 2 + 1] = sampleRight;
}
}
mix(mixedSamples, addr, samples, MAX_VOLUME, MAX_VOLUME, false);
}
/// <summary>
/// Generate a hashCode on a memory range using a rather simple but fast method.
/// </summary>
/// <param name="hashCode"> current hashCode value </param>
/// <param name="addr"> start of the memory range to be hashed </param>
/// <param name="lengthInBytes"> Length of the memory range </param>
/// <returns> updated hashCode value </returns>
public static int getHashCode(int hashCode, int addr, int lengthInBytes)
{
IMemoryReader memoryReader = MemoryReader.getMemoryReader(addr, lengthInBytes, 4);
for (int i = 0, j = 0; i < lengthInBytes; i += 4, j++)
{
int value = memoryReader.readNext();
hashCode ^= value + salt[j & 0xFF];
hashCode += i + addr;
}
return(hashCode);
}
public sbyte[] getArray8(int offset, sbyte[] bytes, int bytesOffset, int n)
{
if (NotNull)
{
IMemoryReader memoryReader = MemoryReader.getMemoryReader(Memory, Address + offset, n, 1);
for (int i = 0; i < n; i++)
{
bytes[bytesOffset + i] = (sbyte)memoryReader.readNext();
}
}
return(bytes);
}
private static int getListSize(int listAddr)
{
IMemoryReader memoryReader = MemoryReader.getMemoryReader(listAddr, 4);
for (int i = 1; true; i++)
{
int instruction = memoryReader.readNext();
int cmd = VideoEngine.command(instruction);
if (cmd == GeCommands.RET)
{
return(i);
}
}
}
private static int sceGuSetMatrix4x3(IMemoryWriter listWriter, IMemoryReader matrixReader, int startCmd, int matrixCmd, int index)
{
listWriter.writeNext((startCmd << 24) + index);
int cmd = matrixCmd << 24;
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 3; j++)
{
listWriter.writeNext(cmd | ((int)((uint)matrixReader.readNext() >> 8)));
}
matrixReader.skip(1);
}
return(52);
}
public RandomTextureAccessReader(IMemoryReader imageReader, int width, int height)
{
this.width = width;
this.height = height;
// Read the whole texture into the "pixels" array
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'sealed override':
//ORIGINAL LINE: sealed override int Length = width * height;
int Length = width * height;
pixels = new int[Length];
for (int i = 0; i < Length; i++)
{
pixels[i] = imageReader.readNext();
}
}
/// <summary>
/// Generate a hashCode on a memory range using a more complex but slower method.
/// </summary>
/// <param name="hashCode"> current hashCode value </param>
/// <param name="addr"> start of the memory range to be hashed </param>
/// <param name="lengthInBytes"> Length of the memory range </param>
/// <returns> updated hashCode value </returns>
public static int getHashCodeComplex(int hashCode, int addr, int lengthInBytes)
{
IMemoryReader memoryReader = MemoryReader.getMemoryReader(addr, lengthInBytes, 4);
int n = lengthInBytes / 4;
for (int i = 0; i < n; i++)
{
int value = memoryReader.readNext();
value = Integer.rotateLeft(value, i & 31);
hashCode ^= value + i + addr;
hashCode += i + addr;
}
return(hashCode);
}
public virtual int sceZlibDecompress(TPointer outBufferAddr, int outBufferLength, TPointer inBufferAddr, TPointer32 crc32Addr)
{
sbyte[] inBuffer = new sbyte[4096];
sbyte[] outBuffer = new sbyte[4096];
int inBufferPtr = 0;
IMemoryReader reader = MemoryReader.getMemoryReader(inBufferAddr.Address, 1);
IMemoryWriter writer = MemoryWriter.getMemoryWriter(outBufferAddr.Address, outBufferLength, 1);
CRC32 crc32 = new CRC32();
Inflater inflater = new Inflater();
while (!inflater.finished())
{
if (inflater.needsInput())
{
for (inBufferPtr = 0; inBufferPtr < inBuffer.Length; ++inBufferPtr)
{
inBuffer[inBufferPtr] = (sbyte)reader.readNext();
}
inflater.Input = inBuffer;
}
try
{
int count = inflater.inflate(outBuffer);
if (inflater.TotalOut > outBufferLength)
{
Console.WriteLine(string.Format("sceZlibDecompress : zlib decompress buffer too small inBuffer={0}, outLength={1:D}", inBufferAddr, outBufferLength));
return(SceKernelErrors.ERROR_INVALID_SIZE);
}
crc32.update(outBuffer, 0, count);
for (int i = 0; i < count; ++i)
{
writer.writeNext(outBuffer[i] & 0xFF);
}
}
catch (DataFormatException)
{
Console.WriteLine(string.Format("sceZlibDecompress : malformed zlib stream inBuffer={0}", inBufferAddr));
return(SceKernelErrors.ERROR_INVALID_FORMAT);
}
}
writer.flush();
crc32Addr.setValue((int)crc32.Value);
return(inflater.TotalOut);
}
public static void mixMonoToStereo(int leftChannelAddrReg, int rightChannelAddrReg, int stereoChannelAddrReg, int lengthReg, int lengthStep)
{
int leftChannelAddr = getRegisterValue(leftChannelAddrReg);
int rightChannelAddr = getRegisterValue(rightChannelAddrReg);
int stereoChannelAddr = getRegisterValue(stereoChannelAddrReg);
int Length = getRegisterValue(lengthReg) * lengthStep;
IMemoryReader leftChannelReader = MemoryReader.getMemoryReader(leftChannelAddr, Length, 2);
IMemoryReader rightChannelReader = MemoryReader.getMemoryReader(rightChannelAddr, Length, 2);
IMemoryWriter stereoChannelWriter = MemoryWriter.getMemoryWriter(stereoChannelAddr, Length << 1, 2);
for (int i = 0; i < Length; i += 2)
{
int left = leftChannelReader.readNext();
int right = rightChannelReader.readNext();
stereoChannelWriter.writeNext(left);
stereoChannelWriter.writeNext(right);
}
stereoChannelWriter.flush();
}
public static void call(int src1AddrReg, int src2AddrReg, int n, int resultReg, int equalValue, int notEqualValue)
{
int src1Addr = getRegisterValue(src1AddrReg);
int src2Addr = getRegisterValue(src2AddrReg);
IMemoryReader memoryReader1 = MemoryReader.getMemoryReader(src1Addr, n, 4);
IMemoryReader memoryReader2 = MemoryReader.getMemoryReader(src2Addr, n, 4);
for (int i = 0; i < n; i += 4)
{
int value1 = memoryReader1.readNext();
int value2 = memoryReader2.readNext();
if (value1 != value2)
{
setRegisterValue(resultReg, notEqualValue);
return;
}
}
setRegisterValue(resultReg, equalValue);
}
public virtual int hleUtilsBufferCopyWithRange(TPointer outAddr, int outSize, TPointer inAddr, int inSize, int cmd)
{
int originalInSize = inSize;
// The input size needs for some KIRK commands to be 16-bytes aligned
inSize = Utilities.alignUp(inSize, 15);
// Read the whole input buffer, including a possible header
// (up to 144 bytes, depending on the KIRK command)
sbyte[] inBytes = new sbyte[inSize + 144]; // Up to 144 bytes header
IMemoryReader memoryReaderIn = MemoryReader.getMemoryReader(inAddr, inSize, 1);
for (int i = 0; i < inSize; i++)
{
inBytes[i] = (sbyte)memoryReaderIn.readNext();
}
// Some KIRK commands (e.g. PSP_KIRK_CMD_SHA1_HASH) only update a part of the output buffer.
// Read the whole output buffer so that it can be updated completely after the KIRK call.
sbyte[] outBytes = new sbyte[Utilities.alignUp(outSize, 15)];
IMemoryReader memoryReaderOut = MemoryReader.getMemoryReader(outAddr, outBytes.Length, 1);
for (int i = 0; i < outBytes.Length; i++)
{
outBytes[i] = (sbyte)memoryReaderOut.readNext();
}
int result = hleUtilsBufferCopyWithRange(outBytes, 0, outSize, inBytes, 0, originalInSize, cmd);
// Write back the whole output buffer to the memory.
IMemoryWriter memoryWriter = MemoryWriter.getMemoryWriter(outAddr, outSize, 1);
for (int i = 0; i < outSize; i++)
{
memoryWriter.writeNext(outBytes[i] & 0xFF);
}
memoryWriter.flush();
return(result);
}
public static int strcmp(int src1Addr, int src2Addr)
{
if (src1Addr == 0)
{
if (src2Addr == 0)
{
return(0);
}
return(-1);
}
if (src2Addr == 0)
{
return(1);
}
IMemoryReader memoryReader1 = MemoryReader.getMemoryReader(src1Addr, 1);
IMemoryReader memoryReader2 = MemoryReader.getMemoryReader(src2Addr, 1);
if (memoryReader1 != null && memoryReader2 != null)
{
while (true)
{
int c1 = memoryReader1.readNext();
int c2 = memoryReader2.readNext();
if (c1 != c2)
{
return(c1 > c2 ? 1 : -1);
}
else if (c1 == 0)
{
// c1 == 0 and c2 == 0
break;
}
}
}
return(0);
}