int main(void)
{
Connection *cnxn = Connection::CreateService("namer");
Message msg, reply;
do_namer_register(NAMER_PORT,"namer");
while(cnxn->Recv(&msg) == 0){
int32 op = -1;
int32 port = -1;
const char *name = 0;
int32 res = -1;
msg.GetInt32('code',&op);
msg.GetInt32('port',&port);
msg.GetString('name',&name);
switch(op){
case NAMER_FIND:
res = do_namer_find(name);
break;
case NAMER_REGISTER:
res = do_namer_register(port, name);
break;
}
reply.Empty();
reply.PutInt32('resp',res);
msg.Reply(&reply);
}
return 0;
}
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;
}
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 RenderAudio(void*)
{
UINT32 buffer_size;
int frame_size = wf_render->nBlockAlign;
audio_client_render->GetBufferSize(&buffer_size);
char* receive_buffer = new char [buffer_size * frame_size * 16]; // Big enough
char* preproccess_buffer = NULL;
char* used_buffer = receive_buffer;
int size;
int offset = 0;
UINT32 padding;
UINT32 frames_available;
UINT32 request_frames;
BYTE* audio_buffer;
bool scale_samples = false;
float sample_coeff;
float one_over_sample_coeff;
/*if (wf_render->nSamplesPerSec != partner_format.nSamplesPerSec)
{
sample_coeff = (float)wf_render->nSamplesPerSec / (float)partner_format.nSamplesPerSec;
one_over_sample_coeff = 1.f / sample_coeff;
preproccess_buffer = new char[buffer_size * frame_size * 16];
scale_samples = true;
used_buffer = preproccess_buffer;
}
else
{
used_buffer = receive_buffer;
}*/
while (true)
{
if (!ReceivingSocket.Recv(receive_buffer, buffer_size * frame_size * 16, size))
{
break;
}
/*if (scale_samples)
{
size = size * sample_coeff;
for (int i = 0; i < size; i += 4)
{
((float*)preproccess_buffer)[i] = ((float*)receive_buffer)[(int)(i * one_over_sample_coeff)];
}
}*/
//printf("Received %d bytes\n", size);
while (size - offset > 0)
{
audio_client_render->GetCurrentPadding(&padding);
frames_available = buffer_size - padding;
request_frames = frames_available < (size - offset) / frame_size ? frames_available : (size - offset) / frame_size;
if (!request_frames)
{
//printf("[DEBUG] Audio loss: %d\n", size - offset);
break;
}
render_client->GetBuffer(request_frames, &audio_buffer);
memcpy(audio_buffer, used_buffer + offset, request_frames * frame_size);
offset += request_frames * frame_size;
render_client->ReleaseBuffer(request_frames, 0);
//Sleep(request_frames * wf_render->nBlockAlign * 1000 / wf_render->nAvgBytesPerSec);
//printf("Cycle: %d, %d, %d\n", size, offset, frames_available);
}
offset = 0;
}
}