void testSysTime() { u64 initial = sceKernelGetSystemTimeWide(); sceKernelDelayThread(1000); u64 diff1 = sceKernelGetSystemTimeWide() - initial; sceKernelDelayThread(1000); u64 diff2 = sceKernelGetSystemTimeWide() - initial - diff1; if ((diff1 + diff2) / 2 > 900 && (diff1 + diff2) / 2 < 1100) { printf("sceKernelGetSystemTimeWide: OK\n"); } else { printf("sceKernelGetSystemTimeWide: %u %u\n", (unsigned int) diff1, (unsigned int) diff2); } }
/** * Handle Hello Packet * @param context Matching Context Pointer * @param sendermac Packet Sender MAC * @param length Packet Length */ void _actOnHelloPacket(SceNetAdhocMatchingContext * context, SceNetEtherAddr * sendermac, uint32_t length) { // Interested in Hello Data if((context->mode == ADHOC_MATCHING_MODE_CHILD && _findParent(context) == NULL) || (context->mode == ADHOC_MATCHING_MODE_P2P && _findP2P(context) == NULL)) { // Complete Packet Header available if(length >= 5) { // Extract Optional Data Length int optlen = 0; memcpy(&optlen, context->rxbuf + 1, sizeof(optlen)); // Complete Valid Packet available if(optlen >= 0 && length >= (5 + optlen)) { // Set Default Null Data void * opt = NULL; // Extract Optional Data Pointer if(optlen > 0) opt = context->rxbuf + 5; // Find Peer SceNetAdhocMatchingMemberInternal * peer = _findPeer(context, sendermac); // Peer not found if(peer == NULL) { // Allocate Memory peer = (SceNetAdhocMatchingMemberInternal *)_malloc(sizeof(SceNetAdhocMatchingMemberInternal)); // Allocated Memory if(peer != NULL) { // Clear Memory memset(peer, 0, sizeof(SceNetAdhocMatchingMemberInternal)); // Copy Sender MAC peer->mac = *sendermac; // Set Peer State peer->state = ADHOC_MATCHING_PEER_OFFER; // Initialize Ping Timer peer->lastping = sceKernelGetSystemTimeWide(); // Link Peer into List peer->next = context->peerlist; context->peerlist = peer; } } // Peer available now if(peer != NULL) { // Spawn Hello Event _spawnLocalEvent(context, ADHOC_MATCHING_EVENT_HELLO, sendermac, optlen, opt); } } } } }
/** * Handle Timeouts in Matching Context * @param context Matchi]ng Context Pointer */ void _handleTimeout(SceNetAdhocMatchingContext * context) { // Iterate Peer List SceNetAdhocMatchingMemberInternal * peer = context->peerlist; while(peer != NULL) { // Get Next Pointer (to avoid crash on memory freeing) SceNetAdhocMatchingMemberInternal * next = peer->next; // Timeout! if((sceKernelGetSystemTimeWide() - peer->lastping) >= (context->keepalive_int * context->keepalivecounter)) { // Spawn Timeout Event if((context->mode == ADHOC_MATCHING_MODE_CHILD && (peer->state == ADHOC_MATCHING_PEER_CHILD || peer->state == ADHOC_MATCHING_PEER_PARENT)) || (context->mode == ADHOC_MATCHING_MODE_PARENT && peer->state == ADHOC_MATCHING_PEER_CHILD) || (context->mode == ADHOC_MATCHING_MODE_P2P && peer->state == ADHOC_MATCHING_PEER_P2P)) _spawnLocalEvent(context, ADHOC_MATCHING_EVENT_TIMEOUT, &peer->mac, 0, NULL); // Delete Peer from List _deletePeer(context, peer); } // Move Pointer peer = next; } }
char* play() { Alert("vplay\n"); delay=1000000000/ot->dmx->fps; next=sceKernelGetSystemTimeWide(); for(u32 s=0; (s<ot->dmx->Vlen); s++) { if(ot->sys->pad&PSP_CTRL_CIRCLE)break; ot->me->nal.nal=ot->dmx->getVSample(s,&ot->me->nal.nalLen); ot->me->nal.mode=s?0:3; sceMpegGetAvcNalAu(Mpeg,&ot->me->nal,ot->me->mpegAu); if(sceMpegAvcDecode(Mpeg,ot->me->mpegAu,ot->lcd->size,0,&ot->me->pics)<0) { blitErr(); //("VdecErr"); continue; } sceMpegAvcDecodeDetail2(Mpeg,&ot->me->d);// ot->me->d = *Mpeg[414]<7?*Mpeg[424]+0x2C:*Mpeg[419]; SceMpegAvcMode mode= {-1,ot->lcd->type}; sceMpegAvcDecodeMode(&ot->me->mpeg,&mode); for(int i=0; i<ot->me->pics; i++) { Mp4AvcYuvStruct*yuv=ot->me->d->yuv+i; Mp4AvcCscStruct csc= {(ot->me->d->info->height+15)>>4,(ot->me->d->info->width+15)>>4,0,0,yuv->b0,yuv->b1,yuv->b2,yuv->b3,yuv->b4,yuv->b5,yuv->b6,yuv->b7}; sceMpegBaseCscAvc(swapBuffer(),0,ot->lcd->size, &csc); if(ot->gui)Draw(2);//draw some overlay stuff } } return NULL; } char* seek(int t,int o) { Alert("vseek\n"); return NULL; }
static void testStateScenarios() { sceDisplayWaitVblankStart(); testIsState(" After start"); sceKernelDelayThread(1000); testIsState(" After vblank end"); // Poll for sync after vblank start. sceDisplayWaitVblankStart(); s64 start = sceKernelGetSystemTimeWide(); s64 end = start + 1000; bool sawVsync = false; bool vblankTimingGood = true; while (sceKernelGetSystemTimeWide() < end) { int vsyncResult = sceDisplayIsVsync(); if (vsyncResult) { testIsState(" During vsync"); sawVsync = true; int untilVsync = (int)(sceKernelGetSystemTimeWide() - start); int untilVblankEnd = 0; while (sceKernelGetSystemTimeWide() < end) { if (!sceDisplayIsVblank()) { untilVblankEnd = (int)(sceKernelGetSystemTimeWide() - start); break; } } if (untilVsync < 500 || untilVsync > 700) { checkpoint(" Vsync did not occur when expected (should be around 631.5us from vblank start)"); vblankTimingGood = false; } if (untilVblankEnd < 600 || untilVblankEnd > 800) { checkpoint(" Vblank did not take as long as expected (should be around 731.5us from vblank start)"); vblankTimingGood = false; } break; } } if (!sawVsync) { checkpoint(" Never received vsync"); } else if (vblankTimingGood) { checkpoint(" Vblank timing checked out"); } }
/** * Handle Ping Packet * @param context Matching Context Pointer * @param sendermac Packet Sender MAC */ void _actOnPingPacket(SceNetAdhocMatchingContext * context, SceNetEtherAddr * sendermac) { // Find Peer SceNetAdhocMatchingMemberInternal * peer = _findPeer(context, sendermac); // Found Peer if(peer != NULL) { // Update Receive Timer peer->lastping = sceKernelGetSystemTimeWide(); } }
/** * Handle Birth Packet * @param context Matching Context Pointer * @param sendermac Packet Sender MAC * @param length Packet Length */ void _actOnBirthPacket(SceNetAdhocMatchingContext * context, SceNetEtherAddr * sendermac, uint32_t length) { // Find Peer SceNetAdhocMatchingMemberInternal * peer = _findPeer(context, sendermac); // Valid Circumstances if(peer != NULL && context->mode == ADHOC_MATCHING_MODE_CHILD && peer == _findParent(context)) { // Complete Packet available if(length >= (1 + sizeof(SceNetEtherAddr))) { // Extract Child MAC SceNetEtherAddr mac; memcpy(&mac, context->rxbuf + 1, sizeof(SceNetEtherAddr)); // Allocate Memory (If this fails... we are f****d.) SceNetAdhocMatchingMemberInternal * sibling = (SceNetAdhocMatchingMemberInternal *)_malloc(sizeof(SceNetAdhocMatchingMemberInternal)); // Allocated Memory if(sibling != NULL) { // Clear Memory memset(sibling, 0, sizeof(SceNetAdhocMatchingMemberInternal)); // Save MAC Address sibling->mac = mac; // Set Peer State sibling->state = ADHOC_MATCHING_PEER_CHILD; // Initialize Ping Timer peer->lastping = sceKernelGetSystemTimeWide(); // Link Peer sibling->next = context->peerlist; context->peerlist = sibling; // Spawn Established Event _spawnLocalEvent(context, ADHOC_MATCHING_EVENT_ESTABLISHED, &sibling->mac, 0, NULL); } } } }
void* swapBuffer() { while((sceKernelGetSystemTimeWide())<next) if(ot->gui)Draw(4); else sceDisplayWaitVblankStart(); next+=delay; /* if(ot->gui){ Draw(8); return (void*)(ot->lcd->curr?ot->lcd->disp:ot->lcd->draw);//+lcd.vram }else{*/ if(ot->lcd->curr^=1) { sceDisplaySetFrameBuf((void*)ot->lcd->draw,ot->lcd->size,ot->lcd->type,0); sceDisplaySetFrameBuf((void*)ot->lcd->disp,ot->lcd->size,ot->lcd->type,1); return (void*)ot->lcd->disp+ot->lcd->vram; } sceDisplaySetFrameBuf((void*)ot->lcd->disp,ot->lcd->size,ot->lcd->type,0); sceDisplaySetFrameBuf((void*)ot->lcd->draw,ot->lcd->size,ot->lcd->type,1); return (void*)ot->lcd->draw+ot->lcd->vram; // } /* // return (void*)0x44000000; */ }
/** * Add Sibling-Data that was sent with Accept-Datagram * @param context Matching Context Pointer * @param siblingcount Number of Siblings * @param siblings Sibling MAC Array */ void _postAcceptAddSiblings(SceNetAdhocMatchingContext * context, int siblingcount, SceNetEtherAddr * siblings) { // Cast Sibling MAC Array to uint8_t // PSP CPU has a problem with non-4-byte aligned Pointer Access. // As the buffer of "siblings" isn't properly aligned I don't want to risk a crash. uint8_t * siblings_u8 = (uint8_t *)siblings; // Iterate Siblings int i = 0; for(; i < siblingcount; i++) { // Allocate Memory SceNetAdhocMatchingMemberInternal * sibling = (SceNetAdhocMatchingMemberInternal *)_malloc(sizeof(SceNetAdhocMatchingMemberInternal)); // Allocated Memory if(sibling != NULL) { // Clear Memory memset(sibling, 0, sizeof(SceNetAdhocMatchingMemberInternal)); // Save MAC Address memcpy(&sibling->mac, siblings_u8 + sizeof(SceNetEtherAddr) * i, sizeof(SceNetEtherAddr)); // Set Peer State sibling->state = ADHOC_MATCHING_PEER_CHILD; // Initialize Ping Timer sibling->lastping = sceKernelGetSystemTimeWide(); // Link Peer sibling->next = context->peerlist; context->peerlist = sibling; // Spawn Established Event _spawnLocalEvent(context, ADHOC_MATCHING_EVENT_ESTABLISHED, &sibling->mac, 0, NULL); } } }
/** * Handle Join Packet * @param context Matching Context Pointer * @param sendermac Packet Sender MAC * @param length Packet Length */ void _actOnJoinPacket(SceNetAdhocMatchingContext * context, SceNetEtherAddr * sendermac, uint32_t length) { // Not a child mode context if(context->mode != ADHOC_MATCHING_MODE_CHILD) { // We still got a unoccupied slot in our room (Parent / P2P) if((context->mode == ADHOC_MATCHING_MODE_PARENT && _countChildren(context) < (context->maxpeers - 1)) || (context->mode == ADHOC_MATCHING_MODE_P2P && _findP2P(context) == NULL)) { // Complete Packet Header available if(length >= 5) { // Extract Optional Data Length int optlen = 0; memcpy(&optlen, context->rxbuf + 1, sizeof(optlen)); // Complete Valid Packet available if(optlen >= 0 && length >= (5 + optlen)) { // Set Default Null Data void * opt = NULL; // Extract Optional Data Pointer if(optlen > 0) opt = context->rxbuf + 5; // Find Peer SceNetAdhocMatchingMemberInternal * peer = _findPeer(context, sendermac); // If we got the peer in the table already and are a parent, there is nothing left to be done. // This is because the only way a parent can know of a child is via a join request... // If we thus know of a possible child, then we already had a previous join request thus no need for double tapping. if(peer != NULL && context->mode == ADHOC_MATCHING_MODE_PARENT) return; // New Peer if(peer == NULL) { // Allocate Memory peer = (SceNetAdhocMatchingMemberInternal *)_malloc(sizeof(SceNetAdhocMatchingMemberInternal)); // Allocated Memory if(peer != NULL) { // Clear Memory memset(peer, 0, sizeof(SceNetAdhocMatchingMemberInternal)); // Copy Sender MAC peer->mac = *sendermac; // Set Peer State peer->state = ADHOC_MATCHING_PEER_INCOMING_REQUEST; // Initialize Ping Timer peer->lastping = sceKernelGetSystemTimeWide(); // Link Peer into List peer->next = context->peerlist; context->peerlist = peer; // Spawn Request Event _spawnLocalEvent(context, ADHOC_MATCHING_EVENT_REQUEST, sendermac, optlen, opt); // Return Success return; } } // Existing Peer (this case is only reachable for P2P mode) else { // Set Peer State peer->state = ADHOC_MATCHING_PEER_INCOMING_REQUEST; // Spawn Request Event _spawnLocalEvent(context, ADHOC_MATCHING_EVENT_REQUEST, sendermac, optlen, opt); // Return Success return; } } } } // Auto-Reject Player _sendCancelPacket(context, sendermac, 0, NULL); } }
/** * Matching IO Handler Thread * @param args sizeof(SceNetAdhocMatchingContext *) * @param argp SceNetAdhocMatchingContext * * @return Exit Point is never reached... */ int _matchingInputThread(uint32_t args, void * argp) { // Cast Context SceNetAdhocMatchingContext * context = *(SceNetAdhocMatchingContext **)argp; // Last Ping uint64_t lastping = 0; // Last Hello uint64_t lasthello = 0; // Run while needed... while(context->input_thid > 0) { // Hello Message Sending Context with unoccupied Slots if((context->mode == ADHOC_MATCHING_MODE_PARENT && _countChildren(context) < (context->maxpeers - 1)) || (context->mode == ADHOC_MATCHING_MODE_P2P && _findP2P(context) == NULL)) { // Hello Message Broadcast necessary because of Hello Interval if((sceKernelGetSystemTimeWide() - lasthello) >= context->hello_int) { // Broadcast Hello Message _broadcastHelloMessage(context); // Update Hello Timer lasthello = sceKernelGetSystemTimeWide(); } } // Ping Required if((sceKernelGetSystemTimeWide() - lastping) >= context->keepalive_int) { // Broadcast Ping Message _broadcastPingMessage(context); // Update Ping Timer lastping = sceKernelGetSystemTimeWide(); } // Messages on Stack ready for processing if(context->input_stack != NULL && context->input_stack_lock == 0) { // Claim Stack context->input_stack_lock = 1; // Iterate Message List ThreadMessage * msg = context->input_stack; for(; msg != NULL; msg = msg->next) { // Default Optional Data void * opt = NULL; // Grab Optional Data if(msg->optlen > 0) opt = ((void *)msg) + sizeof(ThreadMessage); // Send Accept Packet if(msg->opcode == ADHOC_MATCHING_PACKET_ACCEPT) _sendAcceptPacket(context, &msg->mac, msg->optlen, opt); // Send Join Packet else if(msg->opcode == ADHOC_MATCHING_PACKET_JOIN) _sendJoinPacket(context, &msg->mac, msg->optlen, opt); // Send Cancel Packet else if(msg->opcode == ADHOC_MATCHING_PACKET_CANCEL) _sendCancelPacket(context, &msg->mac, msg->optlen, opt); // Send Bulk Data Packet else if(msg->opcode == ADHOC_MATCHING_PACKET_BULK) _sendBulkDataPacket(context, &msg->mac, msg->optlen, opt); // Send Birth Packet else if(msg->opcode == ADHOC_MATCHING_PACKET_BIRTH) _sendBirthPacket(context, &msg->mac); // Cancel Bulk Data Transfer (does nothing as of now as we fire and forget anyway) // else if(msg->opcode == ADHOC_MATCHING_PACKET_BULK_ABORT) blabla; } // Clear IO Message Stack _clearStack(context, ADHOC_MATCHING_INPUT_STACK); // Free Stack context->input_stack_lock = 0; } // Receive PDP Datagram SceNetEtherAddr sendermac; uint16_t senderport; int rxbuflen = context->rxbuflen; int recvresult = sceNetAdhocPdpRecv(context->socket, &sendermac, &senderport, context->rxbuf, &rxbuflen, 0, ADHOC_F_NONBLOCK); // Received Data from a Sender that interests us if(recvresult == 0 && rxbuflen > 0 && context->port == senderport) { // Log Receive Success printk("Received %d Bytes (Opcode: %d)\n", rxbuflen, context->rxbuf[0]); // Ping Packet if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_PING) _actOnPingPacket(context, &sendermac); // Hello Packet else if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_HELLO) _actOnHelloPacket(context, &sendermac, rxbuflen); // Join Packet else if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_JOIN) _actOnJoinPacket(context, &sendermac, rxbuflen); // Accept Packet else if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_ACCEPT) _actOnAcceptPacket(context, &sendermac, rxbuflen); // Cancel Packet else if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_CANCEL) _actOnCancelPacket(context, &sendermac, rxbuflen); // Bulk Data Packet else if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_BULK) _actOnBulkDataPacket(context, &sendermac, rxbuflen); // Birth Packet else if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_BIRTH) _actOnBirthPacket(context, &sendermac, rxbuflen); // Death Packet else if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_DEATH) _actOnDeathPacket(context, &sendermac, rxbuflen); // Bye Packet else if(context->rxbuf[0] == ADHOC_MATCHING_PACKET_BYE) _actOnByePacket(context, &sendermac); // Ignore Incoming Trash Data } // Handle Peer Timeouts _handleTimeout(context); // Share CPU Time sceKernelDelayThread(10000); } // Send Bye Messages _sendByePacket(context); // Free Peer List Buffer _clearPeerList(context); // Delete Pointer Reference (and notify caller about finished cleanup) context->input_thid = 0; // Terminate Thread sceKernelExitDeleteThread(0); // Return Zero to shut up Compiler (never reached anyway) return 0; }
/** * Friend Finder Thread (Receives Peer Information) * @param args Length of argp in Bytes (Unused) * @param argp Argument (Unused) * @return Unused Value - Return 0 */ int _friendFinder(SceSize args, void * argp) { // Receive Buffer int rxpos = 0; uint8_t rx[1024]; // Chat Packet SceNetAdhocctlChatPacketC2S chat; chat.base.opcode = OPCODE_CHAT; // Last Ping Time uint64_t lastping = 0; // Last Time Reception got updated uint64_t lastreceptionupdate = 0; // Finder Loop while(_init == 1) { // Acquire Network Lock _acquireNetworkLock(); // Ping Server if((sceKernelGetSystemTimeWide() - lastping) >= ADHOCCTL_PING_TIMEOUT) { // Update Ping Time lastping = sceKernelGetSystemTimeWide(); // Prepare Packet uint8_t opcode = OPCODE_PING; // Send Ping to Server sceNetInetSend(_metasocket, &opcode, 1, INET_MSG_DONTWAIT); } // Send Chat Messages while(popFromOutbox(chat.message)) { // Send Chat to Server sceNetInetSend(_metasocket, &chat, sizeof(chat), INET_MSG_DONTWAIT); } // Wait for Incoming Data int received = sceNetInetRecv(_metasocket, rx + rxpos, sizeof(rx) - rxpos, INET_MSG_DONTWAIT); // Free Network Lock _freeNetworkLock(); // Received Data if(received > 0) { // Fix Position rxpos += received; // Log Incoming Traffic #ifdef DEBUG printk("Received %d Bytes of Data from Server\n", received); #endif } // Handle Packets if(rxpos > 0) { // BSSID Packet if(rx[0] == OPCODE_CONNECT_BSSID) { // Enough Data available if(rxpos >= sizeof(SceNetAdhocctlConnectBSSIDPacketS2C)) { // Cast Packet SceNetAdhocctlConnectBSSIDPacketS2C * packet = (SceNetAdhocctlConnectBSSIDPacketS2C *)rx; // Update BSSID _parameter.bssid.mac_addr = packet->mac; // Change State _thread_status = ADHOCCTL_STATE_CONNECTED; // Notify Event Handlers int i = 0; for(; i < ADHOCCTL_MAX_HANDLER; i++) { // Active Handler if(_event_handler[i] != NULL) _event_handler[i](ADHOCCTL_EVENT_CONNECT, 0, _event_args[i]); } // Move RX Buffer memmove(rx, rx + sizeof(SceNetAdhocctlConnectBSSIDPacketS2C), sizeof(rx) - sizeof(SceNetAdhocctlConnectBSSIDPacketS2C)); // Fix RX Buffer Length rxpos -= sizeof(SceNetAdhocctlConnectBSSIDPacketS2C); } } // Chat Packet else if(rx[0] == OPCODE_CHAT) { // Enough Data available if(rxpos >= sizeof(SceNetAdhocctlChatPacketS2C)) { // Cast Packet SceNetAdhocctlChatPacketS2C * packet = (SceNetAdhocctlChatPacketS2C *)rx; // Fix for Idiots that try to troll the "ME" Nametag if(stricmp((char *)packet->name.data, "ME") == 0) strcpy((char *)packet->name.data, "NOT ME"); // Add Incoming Chat to HUD addChatLog((char *)packet->name.data, packet->base.message); // Move RX Buffer memmove(rx, rx + sizeof(SceNetAdhocctlChatPacketS2C), sizeof(rx) - sizeof(SceNetAdhocctlChatPacketS2C)); // Fix RX Buffer Length rxpos -= sizeof(SceNetAdhocctlChatPacketS2C); } } // Connect Packet else if(rx[0] == OPCODE_CONNECT) { // Enough Data available if(rxpos >= sizeof(SceNetAdhocctlConnectPacketS2C)) { // Log Incoming Peer #ifdef DEBUG printk("Incoming Peer Data...\n"); #endif // Cast Packet SceNetAdhocctlConnectPacketS2C * packet = (SceNetAdhocctlConnectPacketS2C *)rx; // Add User _addFriend(packet); // Update HUD User Count #ifdef LOCALHOST_AS_PEER setUserCount(_getActivePeerCount()); #else setUserCount(_getActivePeerCount()+1); #endif // Move RX Buffer memmove(rx, rx + sizeof(SceNetAdhocctlConnectPacketS2C), sizeof(rx) - sizeof(SceNetAdhocctlConnectPacketS2C)); // Fix RX Buffer Length rxpos -= sizeof(SceNetAdhocctlConnectPacketS2C); } } // Disconnect Packet else if(rx[0] == OPCODE_DISCONNECT) { // Enough Data available if(rxpos >= sizeof(SceNetAdhocctlDisconnectPacketS2C)) { // Log Incoming Peer Delete Request #ifdef DEBUG printk("Incoming Peer Data Delete Request...\n"); #endif // Cast Packet SceNetAdhocctlDisconnectPacketS2C * packet = (SceNetAdhocctlDisconnectPacketS2C *)rx; // Delete User by IP _deleteFriendByIP(packet->ip); // Update HUD User Count #ifdef LOCALHOST_AS_PEER setUserCount(_getActivePeerCount()); #else setUserCount(_getActivePeerCount()+1); #endif // Move RX Buffer memmove(rx, rx + sizeof(SceNetAdhocctlDisconnectPacketS2C), sizeof(rx) - sizeof(SceNetAdhocctlDisconnectPacketS2C)); // Fix RX Buffer Length rxpos -= sizeof(SceNetAdhocctlDisconnectPacketS2C); } } // Scan Packet else if(rx[0] == OPCODE_SCAN) { // Enough Data available if(rxpos >= sizeof(SceNetAdhocctlScanPacketS2C)) { // Log Incoming Network Information #ifdef DEBUG printk("Incoming Group Information...\n"); #endif // Cast Packet SceNetAdhocctlScanPacketS2C * packet = (SceNetAdhocctlScanPacketS2C *)rx; // Allocate Structure Data SceNetAdhocctlScanInfo * group = (SceNetAdhocctlScanInfo *)malloc(sizeof(SceNetAdhocctlScanInfo)); // Allocated Structure Data if(group != NULL) { // Clear Memory memset(group, 0, sizeof(SceNetAdhocctlScanInfo)); // Link to existing Groups group->next = _networks; // Copy Group Name group->group_name = packet->group; // Set Group Host group->bssid.mac_addr = packet->mac; // Link into Group List _networks = group; } // Move RX Buffer memmove(rx, rx + sizeof(SceNetAdhocctlScanPacketS2C), sizeof(rx) - sizeof(SceNetAdhocctlScanPacketS2C)); // Fix RX Buffer Length rxpos -= sizeof(SceNetAdhocctlScanPacketS2C); } } // Scan Complete Packet else if(rx[0] == OPCODE_SCAN_COMPLETE) { // Log Scan Completion #ifdef DEBUG printk("Incoming Scan complete response...\n"); #endif // Change State _thread_status = ADHOCCTL_STATE_DISCONNECTED; // Notify Event Handlers int i = 0; for(; i < ADHOCCTL_MAX_HANDLER; i++) { // Active Handler if(_event_handler[i] != NULL) _event_handler[i](ADHOCCTL_EVENT_SCAN, 0, _event_args[i]); } // Move RX Buffer memmove(rx, rx + 1, sizeof(rx) - 1); // Fix RX Buffer Length rxpos -= 1; } } // Reception Update required if((sceKernelGetSystemTimeWide() - lastreceptionupdate) > 5000000) { // Clone Time into Last Update Field lastreceptionupdate = sceKernelGetSystemTimeWide(); // Update Reception Level union SceNetApctlInfo info; if(sceNetApctlGetInfo(PSP_NET_APCTL_INFO_STRENGTH, &info) >= 0) setReceptionPercentage((int)info.strength); else setReceptionPercentage(0); } // Delay Thread (10ms) sceKernelDelayThread(10000); } // Set WLAN HUD Reception to 0% on Shutdown setReceptionPercentage(0); // Notify Caller of Shutdown _init = -1; // Log Shutdown printk("End of Friend Finder Thread\n"); // Reset Thread Status _thread_status = ADHOCCTL_STATE_DISCONNECTED; // Kill Thread sceKernelExitDeleteThread(0); // Return Success return 0; }
int Timer::GetTimeInMs() const { return int(sceKernelGetSystemTimeWide() - m_startTime) / 1000; }
void Timer::Start() { m_startTime = sceKernelGetSystemTimeWide(); }
/** * Resolve Player Name to Linked List of Peers * @param nickname To-be-resolved Player Nickname * @param buflen IN: Buffer Length in Bytes OUT: Required / Used Buffer Length in Bytes * @param buf OUT: Resolved Peer Information (if NULL then buflen gets filled with required length) * @return 0 on success or... ADHOCCTL_NOT_INITIALIZED, ADHOCCTL_INVALID_ARG */ int proNetAdhocctlGetAddrByName(const SceNetAdhocctlNickname * nickname, int * buflen, SceNetAdhocctlPeerInfo * buf) { // Library initialized if(_init == 1) { // Valid Arguments if(nickname != NULL && buflen != NULL) { // Multithreading Lock _acquirePeerLock(); // Length Calculation Mode if(buf == NULL) *buflen = _getNicknameCount(nickname) * sizeof(SceNetAdhocctlPeerInfo); // Normal Information Mode else { // Clear Memory memset(buf, 0, *buflen); // Discovered Player Count int discovered = 0; // Calculate Requested Elements int requestcount = *buflen / sizeof(SceNetAdhocctlPeerInfo); // Minimum Space available if(requestcount > 0) { // Local Nickname Matches if(strcmp((char *)_parameter.nickname.data, (char *)nickname->data) == 0) { // Get Local IP Address union SceNetApctlInfo info; if(sceNetApctlGetInfo(PSP_NET_APCTL_INFO_IP, &info) == 0) { // Add Local Address buf[discovered].nickname = _parameter.nickname; sceWlanGetEtherAddr((void *)buf[discovered].mac_addr.data); sceNetInetInetAton(info.ip, &buf[discovered].ip_addr); buf[discovered++].last_recv = sceKernelGetSystemTimeWide(); } } // Peer Reference SceNetAdhocctlPeerInfo * peer = _friends; // Iterate Peers for(; peer != NULL && discovered < requestcount; peer = peer->next) { // Match found if(strcmp((char *)peer->nickname.data, (char *)nickname->data) == 0) { // Fake Receive Time peer->last_recv = sceKernelGetSystemTimeWide(); // Copy Peer Info buf[discovered++] = *peer; } } // Link List int i = 0; for(; i < discovered - 1; i++) { // Link Network buf[i].next = &buf[i + 1]; } // Fix Last Element if(discovered > 0) buf[discovered - 1].next = NULL; } // Fix Buffer Size *buflen = discovered * sizeof(SceNetAdhocctlPeerInfo); } // Multithreading Unlock _freePeerLock(); // Return Success return 0; } // Invalid Arguments return ADHOCCTL_INVALID_ARG; } // Library uninitialized return ADHOCCTL_NOT_INITIALIZED; }