//-----------------------------------------------------------------------------
// msgCreateCommandQueue
//-----------------------------------------------------------------------------
void dcl_message< msgCreateCommandQueue >::create_request( void* payload_ptr )
{
msgCreateCommandQueue_request* request_ptr =
reinterpret_cast< msgCreateCommandQueue_request* >( payload_ptr );
request_ptr->device_id_ = host_to_network( device_id_ );
request_ptr->context_id_ = host_to_network( context_id_ );
request_ptr->properties_ = host_to_network( properties_ );
}
//-----------------------------------------------------------------------------
// msgEnqueueReadBuffer
//-----------------------------------------------------------------------------
void dcl_message< msgEnqueueReadBuffer >::create_request( void* payload_ptr )
{
void* enqueue_ptr = enqueue_message::create_enqueue_request( payload_ptr );
msgEnqueueReadBuffer_request* request_ptr =
reinterpret_cast< msgEnqueueReadBuffer_request* >( enqueue_ptr );
// std::cerr << "read remote message id: " << remote_id_ << std::endl;
request_ptr->id_ = host_to_network( remote_id_ );
request_ptr->size_ = host_to_network( static_cast<uint32_t>( size_ ) );
request_ptr->offset_ = host_to_network( static_cast<uint32_t>( offset_ ) );
}
//-----------------------------------------------------------------------------
// msgEnqueueCopyBuffer
//-----------------------------------------------------------------------------
void dcl_message< msgEnqueueCopyBuffer >::create_request( void* payload_ptr )
{
void* enqueue_ptr = enqueue_message::create_enqueue_request( payload_ptr );
msgEnqueueCopyBuffer_request* request_ptr =
reinterpret_cast< msgEnqueueCopyBuffer_request* >( enqueue_ptr );
request_ptr->src_id_ = host_to_network( src_remote_id_ );
request_ptr->dst_id_ = host_to_network( dst_remote_id_ );
request_ptr->size_ = host_to_network( static_cast<uint32_t>( size_ ) );
request_ptr->src_offset_ = host_to_network( static_cast<uint32_t>( src_offset_ ) );
request_ptr->dst_offset_ = host_to_network( static_cast<uint32_t>( dst_offset_ ) );
}
//-----------------------------------------------------------------------------
void dcl_message< msgEnqueueWriteBuffer >::create_request( void* payload_ptr )
{
void* enqueue_ptr = enqueue_message::create_enqueue_request( payload_ptr );
msgEnqueueWriteBuffer_request* request_ptr =
reinterpret_cast< msgEnqueueWriteBuffer_request* >( enqueue_ptr );
// std::cerr << "write remote message id: " << remote_id_ << std::endl;
request_ptr->id_ = host_to_network( remote_id_ );
request_ptr->buffer_len_ = host_to_network( static_cast<uint32_t>( buffer_len_ ) );
request_ptr->offset_ = host_to_network( static_cast<uint32_t>( offset_ ) );
memcpy( request_ptr->buffer_, buffer_ptr_, buffer_len_ );
}
//-----------------------------------------------------------------------------
// msgCreateBuffer
//-----------------------------------------------------------------------------
void dcl_message< msgCreateBuffer >::create_request( void* payload_ptr )
{
msgCreateBuffer_request* request_ptr =
reinterpret_cast< msgCreateBuffer_request* >( payload_ptr );
request_ptr->context_id_ = host_to_network( context_id_ );
request_ptr->buffer_len_ = host_to_network( static_cast<uint32_t>( buffer_len_ ) );
request_ptr->flags_ = flags_;
request_ptr->message_buffer_ = 0;
if( buffer_ptr_ != NULL )
{
request_ptr->message_buffer_ = 1;
memcpy( request_ptr->buffer_, buffer_ptr_, buffer_len_ );
}
}
//-----------------------------------------------------------------------------
void dcl_message< msgEnqueueReadBuffer >::create_response( void* payload_ptr )
{
msgEnqueueReadBuffer_response* response_ptr =
reinterpret_cast<msgEnqueueReadBuffer_response*>( payload_ptr );
response_ptr->size_ = host_to_network( static_cast<uint32_t>( size_ ) );
memcpy( response_ptr->buffer_, buffer_.data(), size_ );
}
//-----------------------------------------------------------------------------
// msgEnqueueWriteImage
//-----------------------------------------------------------------------------
void dcl_message< msgEnqueueWriteImage >::create_request( void* payload_ptr )
{
void* enqueue_ptr = enqueue_message::create_enqueue_request( payload_ptr );
msgEnqueueWriteImage_request* request_ptr =
reinterpret_cast< msgEnqueueWriteImage_request* >( enqueue_ptr );
request_ptr->remote_id_ = host_to_network( remote_id_ );
request_ptr->row_pitch_ = host_to_network( static_cast<uint32_t>( row_pitch_ ) );
request_ptr->slice_pitch_ = host_to_network( static_cast<uint32_t>( slice_pitch_ ) );
request_ptr->origin_[ 0 ] = host_to_network( static_cast<uint32_t>( origin_[ 0 ] ) );
request_ptr->origin_[ 1 ] = host_to_network( static_cast<uint32_t>( origin_[ 1 ] ) );
request_ptr->origin_[ 2 ] = host_to_network( static_cast<uint32_t>( origin_[ 2 ] ) );
request_ptr->region_[ 0 ] = host_to_network( static_cast<uint32_t>( region_[ 0 ] ) );
request_ptr->region_[ 1 ] = host_to_network( static_cast<uint32_t>( region_[ 1 ] ) );
request_ptr->region_[ 2 ] = host_to_network( static_cast<uint32_t>( region_[ 2 ] ) );
request_ptr->buffer_len_ = host_to_network( static_cast<uint32_t>( buffer_len_ ) );
memcpy( request_ptr->buffer_, buffer_ptr_, buffer_len_ );
}
//-----------------------------------------------------------------------------
// msgCreateImage2D
//-----------------------------------------------------------------------------
void dcl_message< msgCreateImage2D >::create_request( void* payload_ptr )
{
msgCreateImage2D_request* request_ptr =
reinterpret_cast< msgCreateImage2D_request* >( payload_ptr );
request_ptr->context_id_ = host_to_network( context_id_ );
request_ptr->flags_ = static_cast<uint8_t>( flags_ );
request_ptr->channel_order = channel_order_to_network();
request_ptr->channel_type = channel_type_to_network();
request_ptr->width_ = host_to_network( static_cast<uint32_t>( width_ ) );
request_ptr->height_ = host_to_network( static_cast<uint32_t>( height_ ) );
request_ptr->row_pitch_ = host_to_network( static_cast<uint32_t>( row_pitch_ ) );
request_ptr->buffer_len_ = host_to_network( static_cast<uint32_t>( buffer_len_ ) );
request_ptr->message_buffer_ = 0;
if( buffer_ptr_ != NULL )
{
request_ptr->message_buffer_ = 1;
memcpy( request_ptr->buffer_, buffer_ptr_, buffer_len_ );
}
}
int WritePacket( const PacketReadWriteInfo & info, Packet * packet, uint8_t * buffer, int bufferSize )
{
assert( packet );
assert( buffer );
assert( bufferSize > 0 );
assert( info.protocolId );
assert( info.packetFactory );
assert( info.streamAllocator );
const int numPacketTypes = info.packetFactory->GetNumPacketTypes();
WriteStream stream( buffer, bufferSize, *info.streamAllocator );
stream.SetContext( info.context );
for ( int i = 0; i < info.prefixBytes; ++i )
{
uint8_t zero = 0;
if ( !stream.SerializeBits( zero, 8 ) )
{
debug_printf( "serialize prefix byte failed (write packet)\n" );
return 0;
}
}
uint32_t crc32 = 0;
if ( !info.rawFormat )
{
if ( !stream.SerializeBits( crc32, 32 ) )
{
debug_printf( "serialize crc32 failed (write packet)\n" );
return 0;
}
}
int packetType = packet->GetType();
assert( numPacketTypes > 0 );
if ( numPacketTypes > 1 )
{
if ( !stream.SerializeInteger( packetType, 0, numPacketTypes - 1 ) )
return 0;
}
if ( !packet->SerializeInternal( stream ) )
{
debug_printf( "serialize packet type %d failed (write packet)\n", packetType );
return 0;
}
if ( !stream.SerializeCheck( "end of packet" ) )
{
debug_printf( "serialize check at end of packed failed (write packet)\n" );
return 0;
}
stream.Flush();
if ( !info.rawFormat )
{
uint32_t network_protocolId = host_to_network( info.protocolId );
crc32 = calculate_crc32( (uint8_t*) &network_protocolId, 4 );
crc32 = calculate_crc32( buffer + info.prefixBytes, stream.GetBytesProcessed() - info.prefixBytes, crc32 );
*((uint32_t*)(buffer+info.prefixBytes)) = host_to_network( crc32 );
}
if ( stream.GetError() )
{
debug_printf( "stream error %d (write packet)\n", stream.GetError() );
return 0;
}
return stream.GetBytesProcessed();
}
Packet * ReadPacket( const PacketReadWriteInfo & info, const uint8_t * buffer, int bufferSize, int * errorCode )
{
assert( buffer );
assert( bufferSize > 0 );
assert( info.protocolId != 0 );
assert( info.packetFactory );
assert( info.streamAllocator );
if ( errorCode )
*errorCode = YOJIMBO_PROTOCOL_ERROR_NONE;
ReadStream stream( buffer, bufferSize, *info.streamAllocator );
stream.SetContext( info.context );
for ( int i = 0; i < info.prefixBytes; ++i )
{
uint32_t dummy = 0;
if ( !stream.SerializeBits( dummy, 8 ) )
{
debug_printf( "serialize prefix byte failed (read packet)\n" );
return 0;
}
}
uint32_t read_crc32 = 0;
if ( !info.rawFormat )
{
if ( !stream.SerializeBits( read_crc32, 32 ) )
{
debug_printf( "serialize crc32 failed (read packet)\n" );
return 0;
}
uint32_t network_protocolId = host_to_network( info.protocolId );
uint32_t crc32 = calculate_crc32( (const uint8_t*) &network_protocolId, 4 );
uint32_t zero = 0;
crc32 = calculate_crc32( (const uint8_t*) &zero, 4, crc32 );
crc32 = calculate_crc32( buffer + info.prefixBytes + 4, bufferSize - 4 - info.prefixBytes, crc32 );
if ( crc32 != read_crc32 )
{
debug_printf( "corrupt packet. expected crc32 %x, got %x (read packet)\n", crc32, read_crc32 );
if ( errorCode )
*errorCode = YOJIMBO_PROTOCOL_ERROR_CRC32_MISMATCH;
return NULL;
}
}
int packetType = 0;
const int numPacketTypes = info.packetFactory->GetNumPacketTypes();
assert( numPacketTypes > 0 );
if ( numPacketTypes > 1 )
{
if ( !stream.SerializeInteger( packetType, 0, numPacketTypes - 1 ) )
{
debug_printf( "invalid packet type %d (read packet)\n", packetType );
if ( errorCode )
*errorCode = YOJIMBO_PROTOCOL_ERROR_INVALID_PACKET_TYPE;
return NULL;
}
}
if ( info.allowedPacketTypes )
{
if ( !info.allowedPacketTypes[packetType] )
{
debug_printf( "packet type %d not allowed (read packet)\n", packetType );
if ( errorCode )
*errorCode = YOJIMBO_PROTOCOL_ERROR_PACKET_TYPE_NOT_ALLOWED;
return NULL;
}
}
Packet * packet = info.packetFactory->CreatePacket( packetType );
if ( !packet )
{
debug_printf( "create packet type %d failed (read packet)\n", packetType );
if ( errorCode )
*errorCode = YOJIMBO_PROTOCOL_ERROR_CREATE_PACKET_FAILED;
return NULL;
}
if ( !packet->SerializeInternal( stream ) )
{
debug_printf( "serialize packet type %d failed (read packet)\n", packetType );
if ( errorCode )
*errorCode = YOJIMBO_PROTOCOL_ERROR_SERIALIZE_PACKET_FAILED;
goto cleanup;
}
#if YOJIMBO_SERIALIZE_CHECKS
if ( !stream.SerializeCheck( "end of packet" ) )
{
debug_printf( "serialize check failed at end of packet type %d (read packet)\n", packetType );
if ( errorCode )
*errorCode = YOJIMBO_PROTOCOL_ERROR_SERIALIZE_CHECK_FAILED;
goto cleanup;
}
#endif // #if YOJIMBO_SERIALIZE_CHECKS
if ( stream.GetError() )
{
debug_printf( "stream error %d (read packet)\n", stream.GetError() );
if ( errorCode )
*errorCode = stream.GetError();
goto cleanup;
}
return packet;
cleanup:
info.packetFactory->DestroyPacket( packet );
return NULL;
}
//-----------------------------------------------------------------------------
// msgFinish
//-----------------------------------------------------------------------------
void dcl_message< msgFinish >::create_request( void* payload_ptr )
{
remote_id_t* request_ptr = reinterpret_cast< remote_id_t* >( payload_ptr );
*request_ptr = host_to_network( remote_id_ );
}
//-----------------------------------------------------------------------------
void dcl_message< msgCreateCommandQueue >::create_response( void* payload_ptr )
{
remote_id_t* response_ptr = reinterpret_cast< remote_id_t* >( payload_ptr );
*response_ptr = host_to_network( remote_id_ );
}
