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); }