//----------------------------------------------------------------------------------------------------
bool EEVideo::DecodePacket(int _num)
{
if (_num < GetPacketSize())
{
int got = 0;
AVFrame *frame = av_frame_alloc();
if (avcodec_decode_video2(m_codecContext, frame, &got, m_packets[_num]) < 0)
{
printf("Error in decoding video frame.\n");
}
if (got > 0)
{
if (m_swsContext)
{
sws_scale(m_swsContext, frame->data, frame->linesize, 0, m_codecContext->height, m_frameRGBA->data, m_frameRGBA->linesize);
m_frames.push(std::pair<int64_t, EETexture>(frame->pkt_pts, EETexture((unsigned char*)m_frameRGBA->data[0], m_width, m_height)));
av_frame_free(&frame);
return true;
}
}
else
{
// todo: handle the rest
// printf("%d\n", _num);
}
av_frame_free(&frame);
}
return false;
}
bool PacketBuffer::IsAbleToGetPacket() const
{
const uint16 packetSize = GetPacketSize();
if (packetSize == 0)
return false;
const uint16 packetBufferSize = GetBufferSize();
if (packetBufferSize == 0)
return false;
return (packetSize <= packetBufferSize);
}
RakNet::SystemAddress Common::ConnectBlocking(const char *defaultAddress, unsigned short defaultPort)
{
char ipAddr[64];
{
{
strcpy(ipAddr, defaultAddress);
}
}
if (rakInterface->Connect(ipAddr, defaultPort, "MAME", (int)strlen("MAME"))!=RakNet::CONNECTION_ATTEMPT_STARTED)
{
printf("Failed connect call for %s : %d.\n", defaultAddress, int(defaultPort) );
return RakNet::UNASSIGNED_SYSTEM_ADDRESS;
}
printf("Connecting to %s:%d...",ipAddr,defaultPort);
RakNet::Packet *packet;
while (1)
{
for (packet=rakInterface->Receive(); packet; rakInterface->DeallocatePacket(packet), packet=rakInterface->Receive())
{
if (packet->data[0]==ID_CONNECTION_REQUEST_ACCEPTED)
{
printf("Connected!\n");
return packet->systemAddress;
}
else if(packet->data[0]==ID_SERVER_INPUTS)
{
peerInputs[1].push_back(string(((char*)GetPacketData(packet)),(int)GetPacketSize(packet)));
}
else if(packet->data[0]==ID_CLIENT_INPUTS)
{
if(peerIDs.find(packet->guid)==peerIDs.end() || peerInputs.find(peerIDs[packet->guid])==peerInputs.end())
{
if(unknownPeerInputs.find(packet->guid)==unknownPeerInputs.end())
{
unknownPeerInputs[packet->guid] = vector<string>();
}
unknownPeerInputs[packet->guid].push_back(string((char*)GetPacketData(packet),(int)GetPacketSize(packet)));
}
else
{
peerInputs[peerIDs[packet->guid]].push_back(string((char*)GetPacketData(packet),(int)GetPacketSize(packet)));
}
}
else
{
printf("Failed: %d\n",int(packet->data[0]));
return RakNet::UNASSIGNED_SYSTEM_ADDRESS;
}
//JJG: Need to sleep for 1/10th a sec here osd_sleep(100);
}
}
}
unsigned int WINAPI RecvThreadProc(LPVOID argv)
{
SOCKET hServSock = (SOCKET) argv;
CustomBuffer packetBuffer(BUF_SIZE);
char* message = new char[BUF_SIZE];
unsigned short packetSize = 0;
unsigned short messageLength = 0;
PacketType packetType = PACKET_NONE;
while(true)
{
memset(message, 0, sizeof(char)*BUF_SIZE);
packetSize = GetPacketSize(hServSock);
if(RecvMessage(hServSock, packetBuffer.GetBuffer(), packetSize) == SOCKET_ERROR)
{
ErrorHandling("RecvMessage(): error!", GetLastError());
getchar();
exit(1);
}
packetBuffer.Commit(packetSize);
packetBuffer.Read((char*)&packetType, 1);
packetBuffer.Read(message, packetSize - 1);
switch(packetType)
{
case PACKET_ENTER:
Log("Enter CSTalk");
break;
case PACKET_CHAT:
Log(message);
break;
case PACKET_EXIT:
break;
default:
break;
}
}
return 0;
}
// Overridden from MenloDispatchObject
unsigned long
MenloRadio::Poll()
{
int retVal;
MenloRadioEventArgs eventArgs;
unsigned long pollInterval = MAX_POLL_TIME;
//
// If we have a registered receive event we poll the
// radio for receive data.
//
if (m_eventList.HasListeners() && ReceiveDataReady()) {
m_radioActivity = true; // Indicate activity to the power timer
m_receiveEventSignaled = true;
}
// If radio receive data raise the receiveEvent
if (!m_receiveEventSignaled) {
return pollInterval;
}
m_receiveEventSignaled = false;
// 0 timeout since we only read when data is ready
retVal = Read(0);
if (retVal > 0) {
eventArgs.data = GetReceiveBuffer();
eventArgs.dataLength = GetPacketSize();
// Send event to listeners
pollInterval = m_eventList.DispatchEvents(this, &eventArgs);
}
else {
DBG_PRINT("MenloRadio No data on read!");
}
return pollInterval;
}
CGTelentList::CGTelentList()
{
m_nLength = GetPacketSize();
m_pData = new char[m_nLength];
memset(m_pData,0,m_nLength);
}
CGModifyFormation::CGModifyFormation()
{
m_nLength = GetPacketSize();
m_pData = new char[m_nLength];
memset(m_pData,0,m_nLength);
}
CGStarringAttribute::CGStarringAttribute()
{
m_nLength = GetPacketSize();
m_pData = new char[m_nLength];
memset(m_pData,0,m_nLength);
}
void
WUploadThread::DoUpload()
{
PRINT("WUploadThread::DoUpload\n");
if (fShutdownFlag && *fShutdownFlag) // Do we need to interrupt?
{
ConnectTimer();
return;
}
// Still connected?
if (!IsInternalThreadRunning())
{
ConnectTimer();
return;
}
// Small files get to bypass queue
if (IsLocallyQueued())
{
if (
(fFile && (fFileSize >= gWin->fSettings->GetMinQueuedSize())) ||
IsManuallyQueued()
)
{
// not yet
fForced = false;
WUploadEvent *lq = new WUploadEvent(WUploadEvent::FileQueued);
if (lq)
{
SendReply(lq);
}
return;
}
fForced = true; // Set this here to avoid duplicate call to DoUpload()
}
// Recheck if IP is ignored or not
//
if (gWin->IsIgnoredIP(fStrRemoteIP) && !IsBlocked())
{
SetBlocked(true);
}
if (IsBlocked())
{
WUploadEvent *wue = new WUploadEvent(WUploadEvent::FileBlocked);
if (wue)
{
if (fTimeLeft != -1)
wue->SetTime(fTimeLeft);
SendReply(wue);
}
return;
}
if (fStartTime == 0)
fStartTime = GetRunTime64();
if (fFile)
{
MessageRef uref(GetMessageFromPool(WTransfer::TransferFileData));
if (uref())
{
// think about doing this in a dynamic way (depending on connection)
double dpps = GetPacketSize() * 1024.0;
uint32 bufferSize = lrint(dpps);
ByteBufferRef buf = GetByteBufferFromPool(bufferSize);
uint8 * scratchBuffer = buf()->GetBuffer();
if (scratchBuffer == NULL)
{
_nobuffer();
return;
}
int32 numBytes = 0;
numBytes = fFile->ReadBlock32(scratchBuffer, bufferSize);
if (numBytes > 0)
{
buf()->SetNumBytes(numBytes, true);
// munge mode
switch (fMungeMode)
{
case WTransfer::MungeModeNone:
{
uref()->AddInt32("mm", WTransfer::MungeModeNone);
break;
}
case WTransfer::MungeModeXOR:
{
for (int32 x = 0; x < numBytes; x++)
scratchBuffer[x] ^= 0xFF;
uref()->AddInt32("mm", WTransfer::MungeModeXOR);
break;
}
default:
{
break;
}
}
if (uref()->AddFlat("data", buf) == B_OK)
{
// possibly do checksums here
uref()->AddInt32("chk", CalculateFileChecksum(buf)); // a little paranoia, due to file-resumes not working.... (TCP should handle this BUT...)
SendMessageToSessions(uref);
// NOTE: RequestOutputQueuesDrainedNotification() can recurse, so we need to update the offset before
// calling it!
fCurrentOffset += numBytes;
if (fTunneled)
{
SignalUpload();
}
else
{
MessageRef drain(GetMessageFromPool());
if (drain())
qmtt->RequestOutputQueuesDrainedNotification(drain);
}
WUploadEvent *update = new WUploadEvent(WUploadEvent::FileDataSent);
if (update)
{
update->SetOffset(fCurrentOffset);
update->SetSize(fFileSize);
update->SetSent(numBytes);
if (fCurrentOffset >= fFileSize)
{
update->SetDone(true); // file done!
update->SetFile(SimplifyPath(fFileUl));
if (gWin->fSettings->GetUploads())
{
SystemEvent( gWin, tr("%1 has finished downloading %2.").arg( GetRemoteUser() ).arg( SimplifyPath(fFileUl) ) );
}
}
SendReply(update);
}
return;
}
else
{
_nobuffer();
return;
}
}
if (numBytes <= 0)
{
NextFile();
SignalUpload();
return;
}
}
}
else
{
while (!fFile)
{
if (fUploads.GetNumItems() != 0)
{
// grab the ref and remove it from the list
fUploads.RemoveHead(fCurrentRef);
fFileUl = MakeUploadPath(fCurrentRef);
#ifdef _DEBUG
// <*****@*****.**> 20021023, 20030702 -- Add additional debug message
WString wul(fFileUl);
PRINT("WUploadThread::DoUpload: filePath = %S\n", wul.getBuffer());
#endif
fFile = new WFile();
Q_CHECK_PTR(fFile);
if (!fFile->Open(fFileUl, QIODevice::ReadOnly)) // probably doesn't exist
{
delete fFile;
fFile = NULL;
fCurFile++;
continue; // onward
}
// got our file!
fFileSize = fFile->Size();
fCurrentOffset = 0; // from the start
if (fCurrentRef()->FindInt64("secret:offset", fCurrentOffset) == B_OK)
{
if (!fFile->Seek(fCurrentOffset)) // <*****@*****.**> 20021026
{
fFile->Seek(0); // this can't fail :) (I hope)
fCurrentOffset = 0;
}
}
// copy the message in our current file ref
MessageRef headRef = fCurrentRef.Clone();
if (headRef())
{
headRef()->what = WTransfer::TransferFileHeader;
headRef()->AddInt64("beshare:StartOffset", fCurrentOffset);
SendMessageToSessions(headRef);
}
fCurFile++;
// Reset statistics
InitTransferRate();
InitTransferETA();
WUploadEvent *started = new WUploadEvent(WUploadEvent::FileStarted);
if (started)
{
started->SetFile(SimplifyPath(fFileUl));
started->SetStart(fCurrentOffset);
started->SetSize(fFileSize);
#ifdef _DEBUG
started->SetSession(fRemoteSessionID);
#endif
SendReply(started);
}
if (gWin->fSettings->GetUploads())
{
SystemEvent( gWin, tr("%1 is downloading %2.").arg( GetRemoteUser() ).arg( SimplifyPath(fFileUl) ) );
}
// nested call
SignalUpload();
return;
}
else
{
PRINT("No more files!\n");
fWaitingForUploadToFinish = true;
SetFinished(true);
if (fTunneled)
{
_OutputQueuesDrained();
}
else
{
MessageRef drain(GetMessageFromPool());
if (drain())
qmtt->RequestOutputQueuesDrainedNotification(drain);
}
break;
}
}
}
}
void
WUploadThread::MessageReceived(const MessageRef & msg, const String & /* sessionID */)
{
PRINT("WUploadThread::MessageReceived\n");
switch (msg()->what)
{
case WTransfer::TransferCommandPeerID:
{
PRINT("WUpload::TransferCommandPeerID\n");
const char *id = NULL;
if (msg()->FindString("beshare:FromSession", id) == B_OK)
{
fRemoteSessionID = QString::fromUtf8(id);
{
const char *name = NULL;
if (msg()->FindString("beshare:FromUserName", name) == B_OK)
{
QString user = QString::fromUtf8(name);
if ((user.isEmpty()) || (fRemoteUser == fRemoteSessionID))
fRemoteUser = GetUserName(fRemoteSessionID);
else
fRemoteUser = user;
}
else
{
fRemoteUser = GetUserName(fRemoteSessionID);
}
}
if (gWin->IsIgnored(fRemoteSessionID, true))
{
SetBlocked(true);
}
WUploadEvent *ui = new WUploadEvent(WUploadEvent::UpdateUI);
if (ui)
{
// ui->SetSession(id);
SendReply(ui);
}
}
bool c = false;
if (!fTunneled && msg()->FindBool("unishare:supports_compression", c) == B_OK)
{
SetCompression(6);
}
double dpps = GetPacketSize() * 1024.0;
int32 pps = lrint(dpps);
if ((msg()->FindInt32("unishare:preferred_packet_size", pps) == B_OK) && (pps < lrint(dpps)))
SetPacketSize((double) pps / 1024.0);
break;
}
case WTransfer::TransferFileList:
{
// TransferFileList(msg);
WMessageEvent *wme = new WMessageEvent(msg);
if (wme)
{
QApplication::postEvent(this, wme);
}
break;
}
}
}
void PacketBuffer::ConsumePacket()
{
const uint16 packetSize = GetPacketSize();
TruncateBuffer(packetSize);
}
uint16 PacketBuffer::GetPayloadBufferSize() const
{
return GetPacketSize() - GetHeaderSize();
}
CGPutOnSoulBead::CGPutOnSoulBead()
{
m_nLength = GetPacketSize();
m_pData = new char[m_nLength];
memset(m_pData,0,m_nLength);
}
void Server::update(running_machine *machine)
{
for(
map<RakNet::RakNetGUID,vector< string > >::iterator it = unknownPeerInputs.begin();
it != unknownPeerInputs.end();
)
{
cout << "GOT UNKNOWN PEER INPUT\n";
if(peerIDs.find(it->first)!=peerIDs.end())
{
int ID = peerIDs[it->first];
for(int a=0;a<it->second.size();a++)
{
peerInputs[ID].push_back(it->second[a]);
}
map<RakNet::RakNetGUID,vector< string > >::iterator itold = it;
it++;
unknownPeerInputs.erase(itold);
}
else
{
it++;
}
}
//cout << "SERVER TIME: " << RakNet::GetTimeMS()/1000.0f/60.0f << endl;
//printf("Updating server\n");
RakNet::Packet *p;
for (p=rakInterface->Receive(); p; rakInterface->DeallocatePacket(p), p=rakInterface->Receive())
{
// We got a packet, get the identifier with our handy function
unsigned char packetIdentifier = GetPacketIdentifier(p);
//printf("GOT PACKET %d\n",int(packetIdentifier));
// Check if this is a network message packet
switch (packetIdentifier)
{
case ID_CONNECTION_LOST:
// Couldn't deliver a reliable packet - i.e. the other system was abnormally
// terminated
case ID_DISCONNECTION_NOTIFICATION:
// Connection lost normally
printf("ID_DISCONNECTION_NOTIFICATION from %s\n", p->systemAddress.ToString(true));
removePeer(p->guid,machine);
break;
case ID_NEW_INCOMING_CONNECTION:
// Somebody connected. We have their IP now
printf("ID_NEW_INCOMING_CONNECTION from %s with GUID %s\n", p->systemAddress.ToString(true), p->guid.ToString());
if(syncHappend)
{
//Sorry, too late
//rakInterface->CloseConnection(p->systemAddress,true);
}
break;
case ID_CLIENT_INFO:
cout << "GOT ID_CLIENT_INFO\n";
//This client is requesting candidacy, set their info
{
char buf[4096];
strcpy(buf,(char*)(p->data+1));
candidateNames[p->systemAddress] = buf;
}
//Find a session index for the player
{
char buf[4096];
buf[0] = ID_SETTINGS;
memcpy(buf+1,&secondsBetweenSync,sizeof(int));
strcpy(buf+1+sizeof(int),username.c_str());
rakInterface->Send(
buf,
1+sizeof(int)+username.length()+1,
HIGH_PRIORITY,
RELIABLE_ORDERED,
ORDERING_CHANNEL_SYNC,
p->guid,
false
);
}
if(acceptedPeers.size()>=maxPeerID-1)
{
//Sorry, no room
rakInterface->CloseConnection(p->systemAddress,true);
}
else if(acceptedPeers.size())
{
printf("Asking other peers to accept %s\n",p->systemAddress.ToString());
waitingForAcceptFrom[p->systemAddress] = std::vector<RakNet::RakNetGUID>();
for(int a=0; a<acceptedPeers.size(); a++)
{
RakNet::RakNetGUID guid = acceptedPeers[a];
waitingForAcceptFrom[p->systemAddress].push_back(guid);
cout << "SENDING ADVERTIZE TO " << guid.ToString() << endl;
char buf[4096];
buf[0] = ID_ADVERTISE_SYSTEM;
strcpy(buf+1,p->systemAddress.ToString(true));
rakInterface->Send(buf,1+strlen(p->systemAddress.ToString(true))+1,HIGH_PRIORITY,RELIABLE_ORDERED,ORDERING_CHANNEL_SYNC,guid,false);
}
printf("Asking other peers to accept\n");
}
else
{
//First client, automatically accept
acceptPeer(p->systemAddress,machine);
}
break;
case ID_INCOMPATIBLE_PROTOCOL_VERSION:
printf("ID_INCOMPATIBLE_PROTOCOL_VERSION\n");
break;
case ID_ACCEPT_NEW_HOST:
{
printf("Accepting new host\n");
RakNet::SystemAddress saToAccept;
saToAccept.SetBinaryAddress(((char*)p->data)+1);
for(int a=0; a<waitingForAcceptFrom[saToAccept].size(); a++)
{
if(waitingForAcceptFrom[saToAccept][a]==p->guid)
{
waitingForAcceptFrom[saToAccept].erase(waitingForAcceptFrom[saToAccept].begin()+a);
break;
}
}
if(waitingForAcceptFrom[saToAccept].empty())
{
cout << "Accepting: " << saToAccept.ToString() << endl;
waitingForAcceptFrom.erase(waitingForAcceptFrom.find(saToAccept));
acceptPeer(saToAccept,machine);
}
}
break;
case ID_REJECT_NEW_HOST:
{
RakNet::SystemAddress saToReject;
saToReject.SetBinaryAddress(((char*)p->data)+1);
printf("Rejecting new client\n");
cout << p->guid.ToString() << " REJECTS " << saToReject.ToString() << endl;
if(waitingForAcceptFrom.find(saToReject)==waitingForAcceptFrom.end())
printf("Could not find waitingForAcceptFrom for this GUID, weird");
else
waitingForAcceptFrom.erase(waitingForAcceptFrom.find(saToReject));
rakInterface->CloseConnection(saToReject,true);
}
break;
case ID_CLIENT_INPUTS:
if(peerIDs.find(p->guid)==peerIDs.end() || peerInputs.find(peerIDs[p->guid])==peerInputs.end())
{
cout << __FILE__ << ":" << __LINE__ << " OOPS!!!!\n";
}
//cout << "GOT CLIENT INPUTS\n";
peerInputs[peerIDs[p->guid]].push_back(string((char*)GetPacketData(p),(int)GetPacketSize(p)));
break;
default:
printf("UNEXPECTED PACKET ID: %d\n",int(packetIdentifier));
break;
}
}
}
CGCulture::CGCulture()
{
m_nLength = GetPacketSize();
m_pData = new char[m_nLength];
memset(m_pData,0,m_nLength);
}
