void _transmit() {
if(sender_sendData() == ENC_COUNTER_WRAPAROUND) {
handshakeState = SENDER_HELLO;
while (HANDSHAKE_FINISHED != handshakeState)
_handshake();
_transmit();
}
}
void WebSocket::_async_read( usr_ptr u, char* request, const boost::system::error_code& error, size_t bytes_transferred )
{
if( !error )
{
if( u->handshaken )
{ // bitch has handshaken. Lets process him :)
size_t start = 0;
size_t offset = 0;
while( offset < bytes_transferred )
offset += u->ftype->unpackFrame( (unsigned char*)(request + offset), bytes_transferred - offset );
if( u->ftype->disconnect( ) )
{
log( "Request from client " + itoa( u->uid ) + " to disconnect" );
_disconnect( u );
delete[ ] request;
return;
}
else
{
std::string response;
std::string req = u->ftype->data( );
size_t b;
switch( _processable->process( req, response ) )
{
case RESPOND:
unsigned char* frame;
b = u->ftype->packFrame( response, frame, false );
_async_send( u, std::string( (char*)frame, b ) );
delete[ ] frame;
break;
case BROADCAST:
_async_broadcast( response );
break;
default:
break;
}
}
// std::cout << "Frames in request: " << framecount << std::endl;
}
else
{// lets shake hands, mr client
log( "Handshaking with client " + itoa( u->uid ) );
_handshake( u, std::string( request, bytes_transferred ) );
}
// request = new char[ _maxBytes ];
u->sock->async_receive( boost::asio::buffer( request, _maxBytes ), boost::bind( &WebSocket::_async_read, this, u, request, _1, _2 ) );
}
else if( error == boost::asio::error::eof )
{
delete[ ] request;
log( "Client " + itoa( u->uid ) + " closed the connection (eof)." );
// u->sock->close( );
_disconnect( u );
}
else
{
delete[ ] request;
log( "Error: " + error.message( ) );
}
}
int main(int argc, char **argv) {
size_t bufPos;
size_t read;
short buffer[BUFFERSIZE];
short encoded[BUFFERSIZE];
struct wavpcm_input input;
struct wavpcm_output output;
struct decode_chunk_struct decode_chunk_left;
struct decode_chunk_struct decode_chunk_right;
struct encode_chunk_struct encode_chunk_left;
struct encode_chunk_struct encode_chunk_right;
// Initializations
srand(time(NULL));
_convFromOctets();
// Construct
buffer_construct();
channel_construct();
sender_construct();
receiver_construct();
// Handshake
#ifndef __ENC_NO_PRINTS__
printf("\n# Key Exchange\n");
printf("--------------\n\n");
#endif
handshakeState = SENDER_HELLO;
while (HANDSHAKE_FINISHED != handshakeState)
_handshake();
// Transmit
memset(&input, 0, sizeof(struct wavpcm_input));
input.resource = INPUTWAVFILE;
memset(&output, 0, sizeof(struct wavpcm_output));
output.resource = OUTPUTWAVFILE;
/* initialize structs */
memset(&encode_chunk_left, 0, sizeof(struct encode_chunk_struct));
memset(&encode_chunk_right, 0, sizeof(struct encode_chunk_struct));
memset(&decode_chunk_left, 0, sizeof(struct decode_chunk_struct));
memset(&decode_chunk_right, 0, sizeof(struct decode_chunk_struct));
/* initializing for quantisation */
encode_chunk_left.Qstep[0] = QSTART;
encode_chunk_right.Qstep[0] = QSTART;
decode_chunk_left.Qstep[0] = QSTART;
decode_chunk_right.Qstep[0] = QSTART;
encode_chunk_left.Qstep[1] = QSTART;
encode_chunk_right.Qstep[1] = QSTART;
decode_chunk_left.Qstep[1] = QSTART;
decode_chunk_right.Qstep[1] = QSTART;
encode_chunk_left.Qstep[2] = QSTART;
encode_chunk_right.Qstep[2] = QSTART;
decode_chunk_left.Qstep[2] = QSTART;
decode_chunk_right.Qstep[2] = QSTART;
encode_chunk_left.Qstep[3] = QSTART;
encode_chunk_right.Qstep[3] = QSTART;
decode_chunk_left.Qstep[3] = QSTART;
decode_chunk_right.Qstep[3] = QSTART;
wavpcm_input_open(&input);
wavpcm_output_copy_settings(&input, &output);
wavpcm_output_open(&output);
for (bufPos = 0; bufPos < input.samplesAvailable ; bufPos += (BUFFERSIZE/2)) {
read = wavpcm_input_read(&input, buffer);
encode(buffer, &encode_chunk_left, &encode_chunk_right, encoded);
while (buffer_isModified()) {}
buffer_write((field_t *) buffer, BUFFERSIZE*sizeof(short));
_transmit();
receiver_receiveData();
buffer_read((field_t *) buffer, BUFFERSIZE*sizeof(short));
decode(&decode_chunk_left, &decode_chunk_right, encoded, buffer);
wavpcm_output_write(&output, buffer, read);
}
wavpcm_output_close(&output);
exit(EXIT_SUCCESS);
}
