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