void Send( GamePadEvent event, MSGINDEX index = 0 )
{
const bool sendingFirstTime = index == 0;
event.id = sendingFirstTime ? m_msgIndex++ : index;
if( !LosePacket() ) // simulate packets loss
m_UDPtoServer.Send( reinterpret_cast< char* >( &event ), sizeof( event ) );
if( sendingFirstTime /*need to re-send after a short wait*/ )
WaitAndSendAsync( event );
}
void Service::Execute(const std::string& host, int port, Command& cmd)
{
cmd.status() = Command::EXECUTING;
Connection *con = new TCPConnection(host, port);
if (!con->Open())
{
delete con;
throw "Could not connect to " + host;
}
con->Send(&cmd.Msg());
Message *rsp = con->Recv();
cmd.ReadMessage(*rsp);
delete rsp;
}
/*!
* \brief Connects and synchronize every entity, as specified in cpw::Remote
* \param entity The root entity from which start connecting. Default value (NULL) makes it use the Top Layer
*
* Connects and synchronize every entity, as specified in cpw::Remote.
*/
void RemoteProtocol::ConnectToAllEntities(cpw::Entity *entity)
{
if (entity == NULL)
entity = layer_tree->GetTopLayer();
if (entity != NULL)
{
std::vector<cpw::RemoteNode> nodes = ((cpw::Remote*) entity)->GetNodes();
std::vector<cpw::RemoteNode>::iterator it;
for (it = nodes.begin(); it != nodes.end(); it++)
{
cpw::RemoteNode n(it->GetIPAddress(), 3000);
Connection *connection = connection_manager->Connect(n);
if (connection != NULL)
{
GetEntityRequestData *message = new GetEntityRequestData();
message->SetEntityId(entity->GetId());
message->SetSendEntity(false);
connection->Send(message);
if ( message )
{
delete message;
message = NULL;
}
}
}
if (entity->isContainer())
{
//create children
for (int i=0; i<entity->GetNumChildren(); i++)
{
cpw::Entity *child=entity->GetChild(i);
ConnectToAllEntities(child);
}
}
}
}
int main(int argc, char** argv)
{
if (!Initialize())
{
cout << "Failed to initialize socket layer\n";
system("pause");
return -1;
}
if (!Bind(PORT))
{
cout << "Failed to bind listening socket\n";
system("pause");
Cleanup();
return -1;
}
Connection SendingSocket;
char choice;
char IP[16];
cout << "Host or Join (h/j)\n";
cin >> choice;
if (choice == 'h')
{
if (!ReceivingSocket.Accept())
{
cout << "Error while connecting to partner\n";
system("pause");
Cleanup();
return -1;
}
if(!SendingSocket.Accept())
{
cout << "Error while connecting to partner\n";
system("pause");
Cleanup();
return -1;
}
}
else
{
cout << "IP: ";
cin >> IP;
if (!SendingSocket.Connect(IP, PORT))
{
cout << "Error while connecting to partner\n";
cout << StringError() << endl;
system("pause");
Cleanup();
return -1;
}
if(!ReceivingSocket.Connect(IP, PORT))
{
cout << "Error while connecting to partner\n";
cout << StringError() << endl;
system("pause");
Cleanup();
return -1;
}
}
HRESULT result;
IAudioCaptureClient* capture_client = NULL;
IAudioClient* audio_client_capture = NULL;
IMMDevice* capture_device = NULL;
IMMDeviceEnumerator* enumerator = NULL;
IPropertyStore* propstore_capture = NULL;
PROPVARIANT pv_capture;
WAVEFORMATEX* wf_capture = NULL;
UINT32 packSize;
UINT32 availableFrames;
UINT32 timeIntervalForBuffer = 1000000;
UINT32 timeIntervalInMilliseconds = timeIntervalForBuffer / 10000;
BYTE* pData = NULL;
DWORD flags;
float index = 0;
result = CoInitialize(0);
if (FAILED(result))
{
printf("Failed to initialize\n");
goto Exit;
}
result = CoCreateInstance(
__uuidof(MMDeviceEnumerator), NULL,
CLSCTX_ALL, __uuidof(IMMDeviceEnumerator),
(void**)&enumerator);
if (FAILED(result))
{
printf("Failed to create device enumerator\n");
goto Exit;
}
result = enumerator->GetDefaultAudioEndpoint(eCapture, eCommunications, &capture_device);
if (FAILED(result))
{
printf("Failed to get capture endpoint handle\n");
goto Exit;
}
PropVariantInit(&pv_capture);
result = capture_device->OpenPropertyStore(STGM_READ, &propstore_capture);
if (FAILED(result))
{
printf("Failed to read device properties\n");
goto Exit;
}
propstore_capture->GetValue(PKEY_Device_FriendlyName, &pv_capture);
printf("Opening capture device: %S\n", pv_capture.pwszVal);
PropVariantClear(&pv_capture);
result = capture_device->Activate(
__uuidof(IAudioClient), CLSCTX_ALL, NULL, (void**)&audio_client_capture);
if (FAILED(result))
{
printf("Failed to activate capture device\n");
goto Exit;
}
result = audio_client_capture->GetMixFormat(&wf_capture);
if (FAILED(result))
{
printf("Failed to get mix format\n");
goto Exit;
}
result = audio_client_capture->Initialize(AUDCLNT_SHAREMODE_SHARED, 0, timeIntervalForBuffer, 0, wf_capture, NULL);
if (FAILED(result))
{
printf("Failed to initialize audio client\n");
goto Exit;
}
printf("Sample rate: %u Hz\n", wf_capture->nSamplesPerSec);
printf("Sample size: %u bits\n", wf_capture->wBitsPerSample);
printf("Size of audio frame: %u bytes\n", wf_capture->nBlockAlign);
printf("Number of channels: %u\n", wf_capture->nChannels);
result = audio_client_capture->Start();
if (FAILED(result))
{
printf("Failed to start recording\n");
goto Exit;
}
result = audio_client_capture->GetService(__uuidof(IAudioCaptureClient), (void**)&capture_client);
if (FAILED(result))
{
printf("Failed to get capture service\n");
goto Exit;
}
// Get render endpoint interface
result = enumerator->GetDefaultAudioEndpoint(eRender, eCommunications, &render_device);
if (FAILED(result))
{
printf("Failed to get render endpoint handle\n");
goto Exit;
}
PropVariantInit(&pv_render);
result = render_device->OpenPropertyStore(STGM_READ, &propstore_render);
if (FAILED(result))
{
printf("Failed to read device properties\n");
goto Exit;
}
propstore_render->GetValue(PKEY_Device_FriendlyName, &pv_render);
printf("Opening render device: %S\n", pv_render.pwszVal);
PropVariantClear(&pv_render);
result = render_device->Activate(
__uuidof(IAudioClient), CLSCTX_ALL, NULL, (void**)&audio_client_render);
if (FAILED(result))
{
printf("Failed to activate render device\n");
goto Exit;
}
result = audio_client_render->GetMixFormat(&wf_render);
if (FAILED(result))
{
printf("Failed to get mix format\n");
goto Exit;
}
result = audio_client_render->Initialize(AUDCLNT_SHAREMODE_SHARED, 0, timeIntervalForBuffer, 0, wf_render, NULL);
if (FAILED(result))
{
printf("Failed to initialize audio client\n");
goto Exit;
}
printf("Sample rate: %u Hz\n", wf_render->nSamplesPerSec);
printf("Sample size: %u bits\n", wf_render->wBitsPerSample);
printf("Size of audio frame: %u bytes\n", wf_render->nBlockAlign);
printf("Number of channels: %u\n", wf_render->nChannels);
result = audio_client_render->Start();
if (FAILED(result))
{
printf("Failed to start recording\n");
goto Exit;
}
result = audio_client_render->GetService(__uuidof(IAudioRenderClient), (void**)&render_client);
if (FAILED(result))
{
printf("Failed to get render service\n");
goto Exit;
}
int partner_format_received_size;
SendingSocket.Send((const char*)wf_capture, sizeof(*wf_capture));
ReceivingSocket.Recv((char*)&partner_format, sizeof(partner_format), partner_format_received_size);
if (last_error != _NO_ERROR)
{
printf("Connection failed\n");
goto Exit;
}
if (partner_format.nSamplesPerSec != wf_render->nSamplesPerSec)
{
/*cout << "Partned format:\n";
cout << partner_format.wBitsPerSample << endl;
cout << partner_format.nSamplesPerSec << endl;
cout << "My format:\n";
cout << wf_render->wBitsPerSample << endl;
cout << wf_render->nSamplesPerSec << endl;*/
printf("Partner capture format unsupported\n");
//goto Exit;
}
LPTHREAD_START_ROUTINE StartRoutine = (LPTHREAD_START_ROUTINE)RenderAudio;
DWORD threadID;
HANDLE hThread = CreateThread(NULL, 0, StartRoutine, NULL, 0, &threadID);
while (true)
{
Sleep(timeIntervalInMilliseconds);
result = capture_client->GetNextPacketSize(&packSize);
if (FAILED(result))
{
printf("Failed to get next pack size\n");
break;
}
while (packSize)
{
result = capture_client->GetBuffer(&pData, &availableFrames, &flags, NULL, NULL);
if (FAILED(result))
{
printf("Failed to get buffer\n");
goto Exit;
}
if (!SendingSocket.Send((const char*)pData, availableFrames * wf_capture->nBlockAlign))
{
if (last_error == SOCKET_CLOSED)
{
printf("Disconnect\n");
}
else
{
printf("Connection broke\n");
}
goto Exit;
}
result = capture_client->ReleaseBuffer(packSize);
result = capture_client->GetNextPacketSize(&packSize);
if (FAILED(result))
{
printf("Failed to release buffer\n");
goto Exit;
}
}
result = capture_client->ReleaseBuffer(packSize);
if (GetAsyncKeyState(VK_ESCAPE))
{
break;
}
}
Exit:
audio_client_capture->Stop();
//TerminateThread(hThread, 0);
audio_client_render->Stop();
SendingSocket.Disconnect();
ReceivingSocket.Disconnect();
SAFE_RELEASE(capture_device);
SAFE_RELEASE(render_device);
SAFE_RELEASE(enumerator);
SAFE_RELEASE(propstore_capture);
SAFE_RELEASE(propstore_render);
SAFE_RELEASE(capture_client);
SAFE_RELEASE(render_client);
SAFE_RELEASE(audio_client_capture);
SAFE_RELEASE(audio_client_render);
system("pause");
return 0;
}
void * http_event_loop(void *arg){
int event_thread_id = (*(int *)arg);
int sock;
ssize_t read_size;
int request_counter=0;
int event_num;
int max_events = 10;
int i;
int ret;
EpollManager *epoll_mng;
Connection *conn = NULL;
struct epoll_event events[max_events];
for(i=0; i<max_events; i++){
memset(&events[i], 0, sizeof(events[i]));
}
epoll_mng = server->getEpoll(event_thread_id);
if(epoll_mng == NULL){
printf("Error: getEpoll returned -1\n");
exit(-1);
}
while(1){
event_num = epoll_wait(epoll_mng->epoll, events, max_events, EPOLL_WAIT_TIMEOUT_MSEC);
if(event_num == -1){ perror("epoll_wait"); break; }
if(IsStop()){ break; }
//printf("##### epoll wait : event num = %d\n", event_num);
for(i=0; i<event_num; i++){
conn = (Connection *)events[i].data.ptr;
if(conn == NULL){
printf("Error: epoll event do not have connection\n");
exit(-1);
}
sock = conn->sock;
if(events[i].events & EPOLLIN){
// Read
ret = conn->Read();
if(ret <= 0 ){ epoll_mng->CloseConnection(conn); delete conn; conn = NULL; continue; }
// Process
ret = conn->Process();
if(ret <= 0 ){ epoll_mng->CloseConnection(conn); delete conn; conn = NULL; continue; }
}
if(events[i].events & EPOLLOUT){
// Send
ret = conn->Send();
if(ret <= 0 ){ epoll_mng->CloseConnection(conn); delete conn; conn = NULL; continue; }
}
if((events[i].events & EPOLLRDHUP) ||
(events[i].events & EPOLLERR) ||
(events[i].events & EPOLLHUP) ){
epoll_mng->CloseConnection(conn); delete conn; conn = NULL;
continue;
}
}
epoll_mng->CheckAndCloseConnections();
}
pthread_exit(NULL);
}
