public virtual int mp4msv_AD3AF34E(TPointer32 unknown1, int unknown2, TPointer unknown3)
{
if (unknown1.Null)
{
return(4);
}
if (unknown1.getValue(0) == 0)
{
return(4);
}
TPointer unknown5 = unknown1.getPointer(0);
if (unknown5.getValue32(184) == 0)
{
return(0x2003);
}
if (unknown2 == 0)
{
return(6);
}
if (unknown5.getValue32(220) == 0 || unknown5.getValue32(220) < unknown2)
{
return(0x2002);
}
int unknown4 = unknown5.getValue32(232) + 52 * (unknown2 - 1);
unknown3.memcpy(unknown4, 40);
return(0);
}
public virtual int sceKernelCancelSema(int semaid, int newcount, TPointer32 numWaitThreadAddr)
{
SceKernelSemaInfo sema = semaMap[semaid];
if (newcount > sema.maxCount)
{
return(ERROR_KERNEL_ILLEGAL_COUNT);
}
// Write previous numWaitThreads count.
numWaitThreadAddr.setValue(sema.NumWaitThreads);
sema.threadWaitingList.removeAllWaitingThreads();
// Reset this semaphore's count based on newcount.
// Note: If newcount is negative, the count becomes this semaphore's initCount.
if (newcount < 0)
{
sema.currentCount = sema.initCount;
}
else
{
sema.currentCount = newcount;
}
onSemaphoreCancelled(semaid);
return(0);
}
public virtual int hleKernelWaitSema(SceKernelSemaInfo sema, int signal, TPointer32 timeoutAddr, bool doCallbacks)
{
if (!tryWaitSemaphore(sema, signal))
{
// Failed, but it's ok, just wait a little
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("hleKernelWaitSema {0} fast check failed", sema));
}
ThreadManForUser threadMan = Modules.ThreadManForUserModule;
SceKernelThreadInfo currentThread = threadMan.CurrentThread;
sema.threadWaitingList.addWaitingThread(currentThread);
// Wait on a specific semaphore
currentThread.wait.Semaphore_id = sema.uid;
currentThread.wait.Semaphore_signal = signal;
threadMan.hleKernelThreadEnterWaitState(PSP_WAIT_SEMA, sema.uid, semaWaitStateChecker, timeoutAddr.Address, doCallbacks);
}
else
{
// Success, do not reschedule the current thread.
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("hleKernelWaitSema {0} fast check succeeded", sema));
}
}
return(0);
}
public virtual int sceNpGetContentRatingFlag(TPointer32 parentalControlAddr, TPointer32 userAgeAddr)
{
parentalControlAddr.setValue(parentalControl);
userAgeAddr.setValue(UserAge);
return(0);
}
public virtual int mp4msv_07C60A23(TPointer unknown1, TPointer32 unknown2, TPointer32 unknown3)
{
unknown1.setValue32(0);
unknown2.setValue(0);
return(0);
}
public virtual int _sce_pspnet_thread_enter(TPointer32 errorAddr)
{
int currentThreadId = Modules.ThreadManForUserModule.CurrentThreadID;
if (!allocatedThreadStructures.ContainsKey(currentThreadId))
{
int size = 92;
int allocateMem = Modules.sceNetIfhandleModule.hleNetMallocInternal(size);
if (allocateMem < 0)
{
errorAddr.setValue(allocateMem);
return(0);
}
RuntimeContext.debugMemory(allocateMem, size);
Memory.Instance.memset(allocateMem, (sbyte)0, size);
allocatedThreadStructures[currentThreadId] = allocateMem;
}
errorAddr.setValue(0);
return(allocatedThreadStructures[currentThreadId]);
}
public virtual int sceMpegBaseYCrCbCopyVme(TPointer destBufferYCrCb, TPointer32 srcBufferYCrCb, int type)
{
SceMpegYCrCbBuffer destMpegYCrCbBuffer = new SceMpegYCrCbBuffer();
destMpegYCrCbBuffer.read(destBufferYCrCb);
SceMpegYCrCbBufferSrc srcMpegYCrCbBuffer = new SceMpegYCrCbBufferSrc();
srcMpegYCrCbBuffer.read(srcBufferYCrCb);
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("sceMpegBaseYCrCbCopyVme destMpegYCrCbBuffer: {0}", destMpegYCrCbBuffer));
Console.WriteLine(string.Format("sceMpegBaseYCrCbCopyVme srcMpegYCrCbBuffer: {0}", srcMpegYCrCbBuffer));
}
Memory mem = destBufferYCrCb.Memory;
int sizeY = srcMpegYCrCbBuffer.frameWidth * srcMpegYCrCbBuffer.frameHeight;
int sizeCrCb = sizeY >> 2;
copy(mem, destMpegYCrCbBuffer.bufferY, srcMpegYCrCbBuffer.bufferY, sizeY);
copy(mem, destMpegYCrCbBuffer.bufferY2, srcMpegYCrCbBuffer.bufferY2, sizeY);
copy(mem, destMpegYCrCbBuffer.bufferCr, srcMpegYCrCbBuffer.bufferCr, sizeCrCb);
copy(mem, destMpegYCrCbBuffer.bufferCb, srcMpegYCrCbBuffer.bufferCb, sizeCrCb);
copy(mem, destMpegYCrCbBuffer.bufferCr2, srcMpegYCrCbBuffer.bufferCr2, sizeCrCb);
copy(mem, destMpegYCrCbBuffer.bufferCb2, srcMpegYCrCbBuffer.bufferCb2, sizeCrCb);
return(0);
}
public virtual int sceLoadCertFromFlash(int unknown1, int unknown2, TPointer32 unknown3, int unknown4, int unknown5, TPointer32 unknown6)
{
unknown3.setValue(0);
unknown6.setValue(7100);
return(0);
}
public virtual int sceParseHttpStatusLine(TPointer header, int headerLength, TPointer32 httpVersionMajorAddr, TPointer32 httpVersionMinorAddr, TPointer32 httpStatusCodeAddr, TPointer32 httpStatusCommentAddr, TPointer32 httpStatusCommentLengthAddr)
{
IMemoryReader memoryReader = MemoryReader.getMemoryReader(header.Address, headerLength, 1);
string headerString = getHeaderString(memoryReader);
Pattern pattern = Pattern.compile("HTTP/(\\d)\\.(\\d)\\s+(\\d+)(.*)");
Matcher matcher = pattern.matcher(headerString);
if (!matcher.matches())
{
return(-1);
}
int httpVersionMajor = int.Parse(matcher.group(1));
int httpVersionMinor = int.Parse(matcher.group(2));
int httpStatusCode = int.Parse(matcher.group(3));
string httpStatusComment = matcher.group(4);
httpVersionMajorAddr.setValue(httpVersionMajor);
httpVersionMinorAddr.setValue(httpVersionMinor);
httpStatusCodeAddr.setValue(httpStatusCode);
httpStatusCommentAddr.setValue(header.Address + headerString.IndexOf(httpStatusComment, StringComparison.Ordinal));
httpStatusCommentLengthAddr.setValue(httpStatusComment.Length);
return(0);
}
public virtual int scePsmfPlayerStart(int psmfPlayer, TPointer32 initPlayInfoAddr, int initPts)
{
// Read the playback parameters.
if (initPlayInfoAddr.NotNull)
{
videoCodec = initPlayInfoAddr.getValue(0);
videoStreamNum = initPlayInfoAddr.getValue(4);
audioCodec = initPlayInfoAddr.getValue(8);
audioStreamNum = initPlayInfoAddr.getValue(12);
playMode = initPlayInfoAddr.getValue(16);
playSpeed = initPlayInfoAddr.getValue(20);
Modules.sceMpegModule.RegisteredVideoChannel = videoStreamNum;
Modules.sceMpegModule.RegisteredAudioChannel = audioStreamNum;
if (log.InfoEnabled)
{
Console.WriteLine(string.Format("Found play info data: videoCodec=0x{0:X}, videoStreamNum={1:D}, audioCodec=0x{2:X}, audioStreamNum={3:D}, playMode={4:D}, playSpeed={5:D}", videoCodec, videoStreamNum, audioCodec, audioStreamNum, playMode, playSpeed));
}
}
this.initPts = initPts;
// Switch to PLAYING.
psmfPlayerStatus = PSMF_PLAYER_STATUS_PLAYING;
lastMpegGetAtracAuResult = 0;
return(0);
}
public virtual int scePsmfGetEPidWithTimestamp(TPointer32 psmf, int ts)
{
PSMFHeader header = getPsmfHeader(psmf);
if (ts < header.PresentationStartTime)
{
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("scePsmfGetEPidWithTimestamp returning 0x{0:X8}(ERROR_PSMF_INVALID_TIMESTAMP)", SceKernelErrors.ERROR_PSMF_INVALID_TIMESTAMP));
}
return(SceKernelErrors.ERROR_PSMF_INVALID_TIMESTAMP);
}
PSMFEntry entry = header.getEPMapEntryWithTimestamp(ts);
if (entry == null)
{
// Unknown error code
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("scePsmfGetEPidWithTimestamp returning -1"));
}
return(-1);
}
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("scePsmfGetEPidWithTimestamp returning id 0x{0:X}", entry.Id));
}
return(entry.Id);
}
private int hleKernelAllocateFpl(int uid, TPointer32 dataAddr, TPointer32 timeoutAddr, bool wait, bool doCallbacks)
{
SceKernelFplInfo fpl = fplMap[uid];
int addr = tryAllocateFpl(fpl);
ThreadManForUser threadMan = Modules.ThreadManForUserModule;
if (addr == 0)
{
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("hleKernelAllocateFpl {0} fast check failed", fpl));
}
if (!wait)
{
return(ERROR_KERNEL_WAIT_CAN_NOT_WAIT);
}
// Go to wait state
SceKernelThreadInfo currentThread = threadMan.CurrentThread;
fpl.threadWaitingList.addWaitingThread(currentThread);
currentThread.wait.Fpl_id = uid;
currentThread.wait.Fpl_dataAddr = dataAddr;
threadMan.hleKernelThreadEnterWaitState(PSP_WAIT_FPL, uid, fplWaitStateChecker, timeoutAddr.Address, doCallbacks);
}
else
{
// Success, do not reschedule the current thread.
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("hleKernelAllocateFpl {0} fast check succeeded", fpl));
}
dataAddr.setValue(addr);
}
return(0);
}
public BlockedPdpRecv(PdpObject pdpObject, TPointer srcMacAddr, TPointer16 portAddr, TPointer data, TPointer32 dataLengthAddr, long timeout) : base(pdpObject, timeout)
{
this.srcMacAddr = srcMacAddr;
this.portAddr = portAddr;
this.data = data;
this.dataLengthAddr = dataLengthAddr;
}
public virtual int sceCtrlGetIdleCancelThreshold(TPointer32 idleresetAddr, TPointer32 idlebackAddr)
{
idleresetAddr.setValue(idlereset);
idlebackAddr.setValue(idleback);
return(0);
}
public virtual int scePsmfPlayerGetCurrentPlayMode(int psmfPlayer, TPointer32 playModeAddr, TPointer32 playSpeedAddr)
{
playModeAddr.setValue(playMode);
playSpeedAddr.setValue(playSpeed);
return(0);
}
public virtual int sceUpdateDownloadConnectServer(TPointer32 unknown1, TPointer32 unknown2)
{
unknown1.setValue(0);
unknown2.setValue(0);
return(SceKernelErrors.ERROR_LIB_UPDATE_LATEST_VERSION_INSTALLED);
}
public virtual int sceMpegBasePESpacketCopy(TPointer32 packetInfo)
{
Memory mem = Memory.Instance;
int infoAddr = packetInfo.Address;
while (infoAddr != 0)
{
int bufferAddr = mem.read32(infoAddr + 0);
int destinationAddr = mem.read32(infoAddr + 4) | MemoryMap.START_RAM;
int nextInfoAddr = mem.read32(infoAddr + 8);
int bufferLength = mem.read32(infoAddr + 12) & 0x00000FFF;
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("sceMpegBasePESpacketCopy packet at 0x{0:X8}: bufferAddr=0x{1:X8}, destinationAddr=0x{2:X8}, nextInfoAddr=0x{3:X8}, bufferLength=0x{4:X}: {5}", infoAddr, bufferAddr, destinationAddr, nextInfoAddr, bufferLength, Utilities.getMemoryDump(bufferAddr, bufferLength)));
}
if (bufferLength == 0)
{
return(SceKernelErrors.ERROR_INVALID_SIZE);
}
mem.memcpy(destinationAddr, bufferAddr, bufferLength);
infoAddr = nextInfoAddr;
}
Modules.sceMpegModule.hleMpegNotifyRingbufferRead();
Modules.sceMpegModule.hleMpegNotifyVideoDecoderThread();
return(0);
}
public virtual int sceKernelCancelMutex(int uid, int newcount, TPointer32 numWaitThreadAddr)
{
SceKernelMutexInfo info = mutexMap[uid];
if (info == null)
{
Console.WriteLine("sceKernelCancelMutex unknown UID " + uid.ToString("x"));
return(ERROR_KERNEL_MUTEX_NOT_FOUND);
}
if (info.lockedCount == 0)
{
Console.WriteLine("sceKernelCancelMutex UID " + uid.ToString("x") + " not locked");
return(-1);
}
if (newcount < 0)
{
newcount = info.initCount;
}
if (newcount > 1 && (info.attr & PSP_MUTEX_ATTR_ALLOW_RECURSIVE) == 0)
{
Console.WriteLine(string.Format("sceKernelCancelMutex uid={0:D}, newcount={1:D} - illegal count", uid, newcount));
return(SceKernelErrors.ERROR_KERNEL_ILLEGAL_COUNT);
}
// Write previous numWaitThreads count.
numWaitThreadAddr.setValue(info.NumWaitingThreads);
info.threadWaitingList.removeAllWaitingThreads();
// Set new count.
info.lockedCount = newcount;
onMutexCancelled(uid);
return(0);
}
public virtual int scePsmfSetPsmf(TPointer32 psmf, TPointer bufferAddr)
{
Modules.sceMpegModule.analyseMpeg(bufferAddr.Address);
PSMFHeader header = Modules.sceMpegModule.psmfHeader;
psmfHeaderMap[bufferAddr.Address] = header;
// PSMF struct:
// This is an internal system data area which is used to store
// several parameters of the file being handled.
// It's size ranges from 28 bytes to 52 bytes, since when a pointer to
// a certain PSMF area does not exist (NULL), it's omitted from the struct
// (e.g.: no mark data or non existant EPMap).
psmf.setValue(0, header.Version); // PSMF version.
psmf.setValue(4, header.HeaderSize); // The PSMF header size (0x800).
psmf.setValue(8, header.StreamSize); // The PSMF stream size.
psmf.setValue(12, 0); // Grouping Period ID.
psmf.setValue(16, 0); // Group ID.
psmf.setValue(20, header.CurrentStreamNumber); // Current stream's number.
psmf.setValue(24, bufferAddr.Address); // Pointer to PSMF header.
// psmf + 28 - Pointer to current PSMF stream info (video/audio).
// psmf + 32 - Pointer to mark data (used for chapters in UMD_VIDEO).
// psmf + 36 - Pointer to current PSMF stream grouping period.
// psmf + 40 - Pointer to current PSMF stream group.
// psmf + 44 - Pointer to current PSMF stream.
// psmf + 48 - Pointer to PSMF EPMap.
return(0);
}
public virtual int scePsmfGetEPWithId(TPointer32 psmf, int id, TPointer32 outAddr)
{
PSMFHeader header = getPsmfHeader(psmf);
PSMFEntry entry = header.getEPMapEntry(id);
if (entry == null)
{
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("scePsmfGetEPWithId returning 0x{0:X8}(ERROR_PSMF_INVALID_ID)", SceKernelErrors.ERROR_PSMF_INVALID_ID));
}
return(SceKernelErrors.ERROR_PSMF_INVALID_ID);
}
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("scePsmfGetEPWithId returning {0}", entry));
}
outAddr.setValue(0, entry.EntryPTS);
outAddr.setValue(4, entry.EntryOffset);
outAddr.setValue(8, entry.EntryIndex);
outAddr.setValue(12, entry.EntryPicOffset);
return(0);
}
public virtual int scePsmfGetStreamSize(TPointer32 psmf, TPointer32 sizeAddr)
{
PSMFHeader header = getPsmfHeader(psmf);
sizeAddr.setValue(header.StreamSize);
return(0);
}
public virtual int scePsmfSpecifyStream(TPointer32 psmf, int streamNum)
{
PSMFHeader header = getPsmfHeader(psmf);
header.StreamNum = streamNum;
return(0);
}
public virtual int sceDNASGetState(TPointer32 stateAddr, TPointer32 errorCodeAddr)
{
stateAddr.setValue(0);
errorCodeAddr.setValue(0);
Managers.eventFlags.sceKernelSetEventFlag(eventFlagUid, 1);
return(0);
}
public virtual int memlmd_EF73E85B(TPointer buffer, int size, TPointer32 resultSize)
{
resultSize.setValue(size);
Modules.LoadCoreForKernelModule.decodeInitModuleData(buffer, size, resultSize);
return(0);
}
public virtual int sceKernelLibcTime(TPointer32 time_t_addr)
{
int seconds = (int)(new DateTime().Ticks / 1000);
time_t_addr.setValue(seconds);
return(seconds);
}
public virtual int sceCtrlPeekLatch(TPointer32 latchAddr)
{
latchAddr.setValue(0, uiMake);
latchAddr.setValue(4, uiBreak);
latchAddr.setValue(8, uiPress);
latchAddr.setValue(12, uiRelease);
return(latchSamplingCount);
}
public virtual int sceCodepage_driver_1D0DE569(TPointer32 unknown1, TPointer32 unknown2, TPointer32 unknown3, TPointer32 unknown4)
{
unknown1.setValue(0);
unknown2.setValue(0);
unknown3.setValue(47880);
unknown4.setValue(128);
return(0);
}
public virtual int sceNpRosterGetBlockListEntryCount(int requestId, TPointer32 options)
{
if (options.NotNull && options.getValue() != 4)
{
return(-1);
}
return(dummyNumberBlockList);
}
public virtual int sceHttpsGetCaList(TPointer rootCAAddr, TPointer32 rootCANumAddr)
{
if (!isHttpsInit)
{
return(ERROR_HTTP_NOT_INIT);
}
return(0);
}
public virtual int scePsmfQueryStreamSize(TPointer bufferAddr, TPointer32 sizeAddr)
{
// Always let sceMpeg handle the PSMF analysis.
Modules.sceMpegModule.analyseMpeg(bufferAddr.Address);
sizeAddr.setValue(Modules.sceMpegModule.psmfHeader.mpegStreamSize);
return(0);
}
