//--------------------------------------------------------------------------
void Client::Connect(const VeChar8* pcName, const VeChar8* pcSrvIp,
VeUInt32 u32Port, const VeChar8* pcSrvPass)
{
VE_AUTO_LOCK_MUTEX(m_kMutex);
Connection* pkConnect = GetConnection(pcName);
if(pkConnect)
{
pkConnect->Connect(pcSrvIp, u32Port, pcSrvPass);
}
}
int main(int argc, char const *argv[])
{
using teamstyle16::Connection;
Connection *connection = Connection::Instance();
if (argc == 1)
connection->Connect();
else if (argc == 2)
connection->Connect(argv[1]);
else if (argc == 3)
connection->Connect(argv[1], argv[2]);
else
{
std::cerr << "Usage: " << argv[0] << " [host] [port]\n";
std::exit(EXIT_FAILURE);
}
try
{
connection->PrepareWork();
while (true)
{
connection->Update();
// If AIMain() returns, we assume the player want to update infos.
AIMain();
}
}
catch (const boost::system::system_error &e)
{
std::clog << "Connection lost: " << e.what() << std::endl;
std::exit(EXIT_FAILURE);
}
catch (const std::exception &e)
{
std::clog << "Exception caught: " << e.what() << std::endl;
std::exit(EXIT_FAILURE);
}
return 0;
}
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;
}