diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/lib/tng_io.c | 1743 | ||||
| -rw-r--r-- | src/lib/tng_io.h | 2 |
2 files changed, 1160 insertions, 585 deletions
diff --git a/src/lib/tng_io.c b/src/lib/tng_io.c index 4f9f768..f2a0e3f 100644 --- a/src/lib/tng_io.c +++ b/src/lib/tng_io.c @@ -236,10 +236,18 @@ struct tng_trajectory { char *output_file_path; /** A handle to the output file */ FILE *output_file; - /** The endianness of the input file */ - tng_file_endianness input_endianness; - /** The endianness of the output file */ - tng_file_endianness output_endianness; + /** Function to swap 32 bit values to and from the endianness of the + * input file */ + tng_function_status (*input_endianness_swap_func_32)(const tng_trajectory_t, int32_t *); + /** Function to swap 64 bit values to and from the endianness of the + * input file */ + tng_function_status (*input_endianness_swap_func_64)(const tng_trajectory_t, int64_t *); + /** Function to swap 32 bit values to and from the endianness of the + * input file */ + tng_function_status (*output_endianness_swap_func_32)(const tng_trajectory_t, int32_t *); + /** Function to swap 64 bit values to and from the endianness of the + * input file */ + tng_function_status (*output_endianness_swap_func_64)(const tng_trajectory_t, int64_t *); /** The endianness of 32 bit values of the current computer */ tng_endianness_32 endianness_32; /** The endianness of 64 bit values of the current computer */ @@ -335,7 +343,7 @@ struct tng_trajectory { * @return TNG_SUCCESS (0) if successful, TNG_FAILURE (1) if the current * byte order is not recognised. */ -static inline tng_function_status tng_byte_order_to_big_endian_32 +static tng_function_status tng_swap_byte_order_big_endian_32 (const tng_trajectory_t tng_data, int32_t *v) { switch(tng_data->endianness_32) @@ -373,7 +381,7 @@ static inline tng_function_status tng_byte_order_to_big_endian_32 * @return TNG_SUCCESS (0) if successful, TNG_FAILURE (1) if the current * byte order is not recognised. */ -static inline tng_function_status tng_byte_order_to_big_endian_64 +static tng_function_status tng_swap_byte_order_big_endian_64 (const tng_trajectory_t tng_data, int64_t *v) { switch(tng_data->endianness_64) @@ -425,7 +433,7 @@ static inline tng_function_status tng_byte_order_to_big_endian_64 * @return TNG_SUCCESS (0) if successful, TNG_FAILURE (1) if the current * byte order is not recognised. */ -static inline tng_function_status tng_byte_order_to_little_endian_32 +static tng_function_status tng_swap_byte_order_little_endian_32 (const tng_trajectory_t tng_data, int32_t *v) { switch(tng_data->endianness_32) @@ -463,7 +471,7 @@ static inline tng_function_status tng_byte_order_to_little_endian_32 * @return TNG_SUCCESS (0) if successful, TNG_FAILURE (1) if the current * byte order is not recognised. */ -static inline tng_function_status tng_byte_order_to_little_endian_64 +static tng_function_status tng_swap_byte_order_little_endian_64 (const tng_trajectory_t tng_data, int64_t *v) { switch(tng_data->endianness_64) @@ -739,11 +747,71 @@ static tng_function_status tng_block_header_read return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, - &block->header_contents_size) != TNG_SUCCESS) + /* If this was the size of the general info block check the endianness */ + if(ftell(tng_data->input_file) < 9) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + /* File is little endian */ + if ( *(const uint8_t*)&block->header_contents_size != 0x00 && + *(const uint8_t*)(&block->header_contents_size + 7) == 0x00) + { + /* If the architecture endianness is little endian no byte swap + * will be needed. Otherwise use the functions to swap to little + * endian */ + if(tng_data->endianness_32 == TNG_LITTLE_ENDIAN_32) + { + tng_data->input_endianness_swap_func_32 = 0; + } + else + { + tng_data->input_endianness_swap_func_32 = + &tng_swap_byte_order_little_endian_32; + } + if(tng_data->endianness_64 == TNG_LITTLE_ENDIAN_64) + { + tng_data->input_endianness_swap_func_64 = 0; + } + else + { + tng_data->input_endianness_swap_func_64 = + &tng_swap_byte_order_little_endian_64; + } + } + /* File is big endian */ + else + { + /* If the architecture endianness is big endian no byte swap + * will be needed. Otherwise use the functions to swap to big + * endian */ + if(tng_data->endianness_32 == TNG_BIG_ENDIAN_32) + { + tng_data->input_endianness_swap_func_32 = 0; + } + else + { + tng_data->input_endianness_swap_func_32 = + &tng_swap_byte_order_big_endian_32; + } + if(tng_data->endianness_64 == TNG_BIG_ENDIAN_64) + { + tng_data->input_endianness_swap_func_64 = 0; + } + else + { + tng_data->input_endianness_swap_func_64 = + &tng_swap_byte_order_big_endian_64; + } + } + } + + if(tng_data->input_endianness_swap_func_64) + { + if(tng_data->input_endianness_swap_func_64(tng_data, + &block->header_contents_size) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } /* Move the reading position to the beginning of the header. */ @@ -782,20 +850,31 @@ static tng_function_status tng_block_header_read /* Copy the respective parameters from the header contents block */ memcpy(&block->block_contents_size, block->header_contents+offset, sizeof(block->block_contents_size)); - if(tng_byte_order_to_big_endian_64(tng_data, &block->block_contents_size) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &block->block_contents_size) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } + offset += sizeof(block->block_contents_size); memcpy(&block->id, block->header_contents+offset, sizeof(block->id)); - if(tng_byte_order_to_big_endian_64(tng_data, &block->id) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &block->id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } + offset += sizeof(block->id); memcpy(block->hash, block->header_contents+offset, TNG_HASH_LEN); @@ -822,11 +901,15 @@ static tng_function_status tng_block_header_read memcpy(&block->block_version, block->header_contents+offset, sizeof(block->block_version)); - if(tng_byte_order_to_big_endian_64(tng_data, &block->block_version) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &block->block_version) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(block->block_version); @@ -938,33 +1021,42 @@ static tng_function_status tng_block_header_write * the whole block at once. */ memcpy(block->header_contents, &block->header_contents_size, sizeof(block->header_contents_size)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->header_contents)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(block->header_contents_size); memcpy(block->header_contents+offset, &block->block_contents_size, sizeof(block->block_contents_size)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->header_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(block->block_contents_size); memcpy(block->header_contents+offset, &block->id, sizeof(block->id)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->header_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(block->id); @@ -976,12 +1068,15 @@ static tng_function_status tng_block_header_write memcpy(block->header_contents+offset, &block->block_version, sizeof(block->block_version)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->header_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(block->block_version); @@ -1171,10 +1266,15 @@ static tng_function_status tng_general_info_block_read memcpy(&tng_data->time, block->block_contents+offset, sizeof(tng_data->time)); - if(tng_byte_order_to_big_endian_64(tng_data, &tng_data->time) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &tng_data->time) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->time); @@ -1184,25 +1284,33 @@ static tng_function_status tng_general_info_block_read memcpy(&tng_data->frame_set_n_frames, block->block_contents+offset, sizeof(tng_data->frame_set_n_frames)); - if(tng_byte_order_to_big_endian_64(tng_data, &tng_data->frame_set_n_frames) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &tng_data->frame_set_n_frames) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->frame_set_n_frames); memcpy(&tng_data->first_trajectory_frame_set_input_file_pos, block->block_contents+offset, sizeof(tng_data->first_trajectory_frame_set_input_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, - &tng_data->first_trajectory_frame_set_input_file_pos) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &tng_data->first_trajectory_frame_set_input_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->first_trajectory_frame_set_input_file_pos); + tng_data->current_trajectory_frame_set.next_frame_set_file_pos = tng_data->first_trajectory_frame_set_input_file_pos; @@ -1210,32 +1318,43 @@ static tng_function_status tng_general_info_block_read memcpy(&tng_data->last_trajectory_frame_set_input_file_pos, block->block_contents+offset, sizeof(tng_data->last_trajectory_frame_set_input_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, - &tng_data->last_trajectory_frame_set_input_file_pos) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &tng_data->last_trajectory_frame_set_input_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->last_trajectory_frame_set_input_file_pos); memcpy(&tng_data->medium_stride_length, block->block_contents+offset, sizeof(tng_data->medium_stride_length)); - if(tng_byte_order_to_big_endian_64(tng_data, &tng_data->medium_stride_length) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &tng_data->medium_stride_length) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->medium_stride_length); memcpy(&tng_data->long_stride_length, block->block_contents+offset, sizeof(tng_data->long_stride_length)); - if(tng_byte_order_to_big_endian_64(tng_data, &tng_data->long_stride_length) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &tng_data->long_stride_length) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } return(TNG_SUCCESS); @@ -1466,12 +1585,15 @@ static tng_function_status tng_general_info_block_write memcpy(block->block_contents+offset, &tng_data->time, sizeof(tng_data->time)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->time); @@ -1481,58 +1603,73 @@ static tng_function_status tng_general_info_block_write memcpy(block->block_contents+offset, &tng_data->frame_set_n_frames, sizeof(tng_data->frame_set_n_frames)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->frame_set_n_frames); memcpy(block->block_contents+offset, &tng_data->first_trajectory_frame_set_input_file_pos, sizeof(tng_data->first_trajectory_frame_set_input_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->first_trajectory_frame_set_input_file_pos); memcpy(block->block_contents+offset, &tng_data->last_trajectory_frame_set_input_file_pos, sizeof(tng_data->last_trajectory_frame_set_input_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->last_trajectory_frame_set_input_file_pos); memcpy(block->block_contents+offset, &tng_data->medium_stride_length, sizeof(tng_data->medium_stride_length)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->medium_stride_length); memcpy(block->block_contents+offset, &tng_data->long_stride_length, sizeof(tng_data->long_stride_length)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(tng_block_header_write(tng_data, block, hash_mode) != TNG_SUCCESS) @@ -1631,11 +1768,15 @@ static tng_function_status tng_molecules_block_read memcpy(&tng_data->n_molecules, block->block_contents, sizeof(tng_data->n_molecules)); - if(tng_byte_order_to_big_endian_64(tng_data, &tng_data->n_molecules) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &tng_data->n_molecules) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->n_molecules); @@ -1680,10 +1821,15 @@ static tng_function_status tng_molecules_block_read memcpy(&molecule->id, block->block_contents+offset, sizeof(molecule->id)); - if(tng_byte_order_to_big_endian_64(tng_data, &molecule->id) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &molecule->id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->id); @@ -1695,10 +1841,15 @@ static tng_function_status tng_molecules_block_read memcpy(&molecule->quaternary_str, block->block_contents+offset, sizeof(molecule->quaternary_str)); - if(tng_byte_order_to_big_endian_64(tng_data, &molecule->quaternary_str) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &molecule->quaternary_str) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->quaternary_str); @@ -1707,11 +1858,15 @@ static tng_function_status tng_molecules_block_read memcpy(&tng_data->molecule_cnt_list[i], block->block_contents+offset, sizeof(int64_t)); - if(tng_byte_order_to_big_endian_64(tng_data, - &tng_data->molecule_cnt_list[i]) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &tng_data->molecule_cnt_list[i]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(int64_t); } @@ -1719,31 +1874,43 @@ static tng_function_status tng_molecules_block_read memcpy(&molecule->n_chains, block->block_contents+offset, sizeof(molecule->n_chains)); - if(tng_byte_order_to_big_endian_64(tng_data, &molecule->n_chains) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &molecule->n_chains) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->n_chains); memcpy(&molecule->n_residues, block->block_contents+offset, sizeof(molecule->n_residues)); - if(tng_byte_order_to_big_endian_64(tng_data, &molecule->n_residues) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &molecule->n_residues) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->n_residues); memcpy(&molecule->n_atoms, block->block_contents+offset, sizeof(molecule->n_atoms)); - if(tng_byte_order_to_big_endian_64(tng_data, &molecule->n_atoms) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &molecule->n_atoms) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->n_atoms); @@ -1793,10 +1960,15 @@ static tng_function_status tng_molecules_block_read memcpy(&chain->id, block->block_contents+offset, sizeof(chain->id)); - if(tng_byte_order_to_big_endian_64(tng_data, &chain->id) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &chain->id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(chain->id); @@ -1809,12 +1981,16 @@ static tng_function_status tng_molecules_block_read memcpy(&chain->n_residues, block->block_contents+offset, sizeof(chain->n_residues)); - if(tng_byte_order_to_big_endian_64(tng_data, &chain->n_residues) + if(tng_data->input_endianness_swap_func_64) + { + if(tng_data->input_endianness_swap_func_64(tng_data, + &chain->n_residues) != TNG_SUCCESS) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); } + } offset += sizeof(chain->n_residues); chain->residues = residue; @@ -1824,10 +2000,15 @@ static tng_function_status tng_molecules_block_read residue->chain = chain; memcpy(&residue->id, block->block_contents+offset, sizeof(residue->id)); - if(tng_byte_order_to_big_endian_64(tng_data, &residue->id) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &residue->id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(residue->id); @@ -1839,12 +2020,16 @@ static tng_function_status tng_molecules_block_read offset += len; memcpy(&residue->n_atoms, block->block_contents+offset, - sizeof(residue->n_atoms)); - if(tng_byte_order_to_big_endian_64(tng_data, &residue->n_atoms) - != TNG_SUCCESS) + sizeof(residue->n_atoms)); + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &residue->n_atoms) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(residue->n_atoms); @@ -1856,10 +2041,15 @@ static tng_function_status tng_molecules_block_read memcpy(&atom->id, block->block_contents+offset, sizeof(atom->id)); - if(tng_byte_order_to_big_endian_64(tng_data, &atom->id) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &atom->id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(atom->id); @@ -1886,11 +2076,15 @@ static tng_function_status tng_molecules_block_read memcpy(&molecule->n_bonds, block->block_contents+offset, sizeof(molecule->n_bonds)); - if(tng_byte_order_to_big_endian_64(tng_data, &molecule->n_bonds) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &molecule->n_bonds) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->n_bonds); @@ -1910,21 +2104,29 @@ static tng_function_status tng_molecules_block_read { memcpy(&bond->from_atom_id, block->block_contents+offset, sizeof(bond->from_atom_id)); - if(tng_byte_order_to_big_endian_64(tng_data, &bond->from_atom_id) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &bond->from_atom_id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(bond->from_atom_id); memcpy(&bond->to_atom_id, block->block_contents+offset, sizeof(bond->to_atom_id)); - if(tng_byte_order_to_big_endian_64(tng_data, &bond->to_atom_id) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &bond->to_atom_id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(bond->to_atom_id); @@ -2105,12 +2307,15 @@ static tng_function_status tng_molecules_block_write memcpy(block->block_contents+offset, &tng_data->n_molecules, sizeof(tng_data->n_molecules)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(tng_data->n_molecules); @@ -2120,12 +2325,15 @@ static tng_function_status tng_molecules_block_write // printf("i=%d\n", i); memcpy(block->block_contents+offset, &molecule->id, sizeof(molecule->id)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->id); @@ -2136,12 +2344,15 @@ static tng_function_status tng_molecules_block_write memcpy(block->block_contents+offset, &molecule->quaternary_str, sizeof(molecule->quaternary_str)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->quaternary_str); @@ -2149,46 +2360,58 @@ static tng_function_status tng_molecules_block_write { memcpy(block->block_contents+offset, &tng_data->molecule_cnt_list[i], sizeof(int64_t)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(int64_t); } memcpy(block->block_contents+offset, &molecule->n_chains, sizeof(molecule->n_chains)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->n_chains); memcpy(block->block_contents+offset, &molecule->n_residues, sizeof(molecule->n_residues)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->n_residues); memcpy(block->block_contents+offset, &molecule->n_atoms, sizeof(molecule->n_atoms)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->n_atoms); @@ -2196,12 +2419,15 @@ static tng_function_status tng_molecules_block_write for(j = molecule->n_chains; j--;) { memcpy(block->block_contents+offset, &chain->id, sizeof(chain->id)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(chain->id); @@ -2211,12 +2437,15 @@ static tng_function_status tng_molecules_block_write memcpy(block->block_contents+offset, &chain->n_residues, sizeof(chain->n_residues)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(chain->n_residues); @@ -2224,12 +2453,15 @@ static tng_function_status tng_molecules_block_write for(k = chain->n_residues; k--;) { memcpy(block->block_contents+offset, &residue->id, sizeof(residue->id)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(residue->id); @@ -2239,12 +2471,15 @@ static tng_function_status tng_molecules_block_write memcpy(block->block_contents+offset, &residue->n_atoms, sizeof(residue->n_atoms)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(residue->n_atoms); @@ -2252,13 +2487,17 @@ static tng_function_status tng_molecules_block_write for(l = residue->n_atoms; l--;) { // printf("j=%d\n", j); - memcpy(block->block_contents+offset, &atom->id, sizeof(atom->id)); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)) - != TNG_SUCCESS) + memcpy(block->block_contents+offset, &atom->id, + sizeof(atom->id)); + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(atom->id); @@ -2279,12 +2518,15 @@ static tng_function_status tng_molecules_block_write memcpy(block->block_contents+offset, &molecule->n_bonds, sizeof(molecule->n_bonds)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(molecule->n_bonds); @@ -2293,22 +2535,29 @@ static tng_function_status tng_molecules_block_write { memcpy(block->block_contents+offset, &bond->from_atom_id, sizeof(bond->from_atom_id)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(bond->from_atom_id); memcpy(block->block_contents+offset, &bond->to_atom_id, sizeof(bond->to_atom_id)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(bond->to_atom_id); @@ -2435,21 +2684,29 @@ static tng_function_status tng_frame_set_block_read memcpy(&frame_set->first_frame, block->block_contents, sizeof(frame_set->first_frame)); - if(tng_byte_order_to_big_endian_64(tng_data, &frame_set->first_frame) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->first_frame) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->first_frame); memcpy(&frame_set->n_frames, block->block_contents + offset, sizeof(frame_set->n_frames)); - if(tng_byte_order_to_big_endian_64(tng_data, &frame_set->n_frames) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->n_frames) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->n_frames); @@ -2477,12 +2734,15 @@ static tng_function_status tng_frame_set_block_read memcpy(&frame_set->molecule_cnt_list[i], block->block_contents + offset, sizeof(int64_t)); - if(tng_byte_order_to_big_endian_64(tng_data, - &frame_set->molecule_cnt_list[i]) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->molecule_cnt_list[i]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(int64_t); frame_set->n_particles += tng_data->molecules[i].n_atoms * @@ -2497,72 +2757,90 @@ static tng_function_status tng_frame_set_block_read memcpy(&frame_set->next_frame_set_file_pos, block->block_contents + offset, sizeof(frame_set->next_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, - &frame_set->next_frame_set_file_pos) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->next_frame_set_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->next_frame_set_file_pos); memcpy(&frame_set->prev_frame_set_file_pos, block->block_contents + offset, sizeof(frame_set->prev_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, - &frame_set->prev_frame_set_file_pos) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->prev_frame_set_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->prev_frame_set_file_pos); memcpy(&frame_set->medium_stride_next_frame_set_file_pos, block->block_contents + offset, sizeof(frame_set->medium_stride_next_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, &frame_set-> - medium_stride_next_frame_set_file_pos) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->medium_stride_next_frame_set_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->medium_stride_next_frame_set_file_pos); memcpy(&frame_set->medium_stride_prev_frame_set_file_pos, block->block_contents + offset, sizeof(frame_set->medium_stride_prev_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, &frame_set-> - medium_stride_prev_frame_set_file_pos) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->medium_stride_prev_frame_set_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->medium_stride_prev_frame_set_file_pos); memcpy(&frame_set->long_stride_next_frame_set_file_pos, block->block_contents + offset, sizeof(frame_set->long_stride_next_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, &frame_set-> - long_stride_next_frame_set_file_pos) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->long_stride_next_frame_set_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->long_stride_next_frame_set_file_pos); memcpy(&frame_set->long_stride_prev_frame_set_file_pos, block->block_contents + offset, sizeof(frame_set->long_stride_prev_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, &frame_set-> - long_stride_prev_frame_set_file_pos) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->long_stride_prev_frame_set_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->long_stride_prev_frame_set_file_pos); @@ -2630,23 +2908,29 @@ static tng_function_status tng_frame_set_block_write memcpy(block->block_contents, &frame_set->first_frame, sizeof(frame_set->first_frame)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->first_frame); memcpy(block->block_contents+offset, &frame_set->n_frames, sizeof(frame_set->n_frames)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->n_frames); @@ -2657,12 +2941,15 @@ static tng_function_status tng_frame_set_block_write memcpy(block->block_contents+offset, &frame_set->molecule_cnt_list[i], sizeof(int64_t)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(int64_t); } @@ -2671,71 +2958,89 @@ static tng_function_status tng_frame_set_block_write memcpy(block->block_contents+offset, &frame_set->next_frame_set_file_pos, sizeof(frame_set->next_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->next_frame_set_file_pos); memcpy(block->block_contents+offset, &frame_set->prev_frame_set_file_pos, sizeof(frame_set->prev_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->prev_frame_set_file_pos); memcpy(block->block_contents+offset, &frame_set->medium_stride_next_frame_set_file_pos, sizeof(frame_set->medium_stride_next_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->medium_stride_next_frame_set_file_pos); memcpy(block->block_contents+offset, &frame_set->medium_stride_prev_frame_set_file_pos, sizeof(frame_set->medium_stride_prev_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->medium_stride_prev_frame_set_file_pos); memcpy(block->block_contents+offset, &frame_set->long_stride_next_frame_set_file_pos, sizeof(frame_set->long_stride_next_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->long_stride_next_frame_set_file_pos); memcpy(block->block_contents+offset, &frame_set->long_stride_prev_frame_set_file_pos, sizeof(frame_set->long_stride_prev_frame_set_file_pos)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(frame_set->long_stride_prev_frame_set_file_pos); @@ -2839,21 +3144,29 @@ static tng_function_status tng_trajectory_mapping_block_read memcpy(&mapping->num_first_particle, block->block_contents+offset, sizeof(mapping->num_first_particle)); - if(tng_byte_order_to_big_endian_64(tng_data, &mapping->num_first_particle) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &mapping->num_first_particle) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(mapping->num_first_particle); memcpy(&mapping->n_particles, block->block_contents+offset, sizeof(mapping->n_particles)); - if(tng_byte_order_to_big_endian_64(tng_data, &mapping->n_particles) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &mapping->n_particles) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(mapping->n_particles); @@ -2866,20 +3179,32 @@ static tng_function_status tng_trajectory_mapping_block_read return(TNG_CRITICAL); } - for(i = 0; i < mapping->n_particles; i++) + /* If the byte order needs to be swapped the data must be read one value at + * a time and swapped */ + if(tng_data->input_endianness_swap_func_64) { - memcpy(&mapping->real_particle_numbers[i], - block->block_contents + offset, - sizeof(int64_t)); - if(tng_byte_order_to_big_endian_64(tng_data, - &mapping->real_particle_numbers[i]) != - TNG_SUCCESS) + for(i = 0; i < mapping->n_particles; i++) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + memcpy(&mapping->real_particle_numbers[i], + block->block_contents + offset, + sizeof(int64_t)); + if(tng_data->input_endianness_swap_func_64(tng_data, + &mapping->real_particle_numbers[i]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } + offset += sizeof(int64_t); } - offset += sizeof(int64_t); } + /* Otherwise the data can be read all at once */ + else + { + memcpy(mapping->real_particle_numbers, block->block_contents + offset, + mapping->n_particles * sizeof(int64_t)); + } + return(TNG_SUCCESS); } @@ -2950,38 +3275,52 @@ static tng_function_status tng_trajectory_mapping_block_write memcpy(block->block_contents, &mapping->num_first_particle, sizeof(mapping->num_first_particle)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(mapping->num_first_particle); memcpy(block->block_contents+offset, &mapping->n_particles, sizeof(mapping->n_particles)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(mapping->n_particles); - for(i = 0; i < mapping->n_particles; i++) + if(tng_data->output_endianness_swap_func_64) { - memcpy(block->block_contents+offset, &mapping->real_particle_numbers[i], - sizeof(int64_t)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + for(i = 0; i < mapping->n_particles; i++) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + memcpy(block->block_contents+offset, &mapping->real_particle_numbers[i], + sizeof(int64_t)); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } + offset += sizeof(int64_t); } - offset += sizeof(int64_t); + } + else + { + memcpy(block->block_contents+offset, mapping->real_particle_numbers, + mapping->n_particles * sizeof(int64_t)); } @@ -3310,6 +3649,8 @@ static tng_function_status tng_particle_data_read n_frames = max(1, n_frames / stride_length); + /* FIXME: If not using a union to store data a whole dimension + * or the whole block can be read at once if byte swapping is not needed */ switch(datatype) { case TNG_FLOAT_DATA: @@ -3323,14 +3664,17 @@ static tng_function_status tng_particle_data_read for(k = 0; k < n_values; k++) { memcpy(&second_dim_values[k].f, - block->block_contents+*offset, - size); - if(tng_byte_order_to_big_endian_32(tng_data, - (int32_t *) &second_dim_values[k]) != TNG_SUCCESS) + block->block_contents+*offset, + size); + if(tng_data->input_endianness_swap_func_32) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_32(tng_data, + (int32_t *)&second_dim_values[k]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } *offset += size; } @@ -3350,12 +3694,15 @@ static tng_function_status tng_particle_data_read memcpy(&second_dim_values[k].i, block->block_contents+*offset, size); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *) &second_dim_values[k].i) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + (int64_t *)&second_dim_values[k]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } *offset += size; } @@ -3406,12 +3753,15 @@ static tng_function_status tng_particle_data_read memcpy(&second_dim_values[k].d, block->block_contents+*offset, size); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *) &second_dim_values[k].d) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + (int64_t *)&second_dim_values[k]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } *offset += size; } @@ -3621,23 +3971,29 @@ static tng_function_status tng_particle_data_block_write memcpy(block->block_contents+offset, &data->n_values_per_frame, sizeof(data->n_values_per_frame)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->n_values_per_frame); memcpy(block->block_contents+offset, &data->codec_id, sizeof(data->codec_id)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->codec_id); @@ -3645,12 +4001,15 @@ static tng_function_status tng_particle_data_block_write { memcpy(block->block_contents+offset, &data->compression_multiplier, sizeof(data->compression_multiplier)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->compression_multiplier); } @@ -3662,23 +4021,29 @@ static tng_function_status tng_particle_data_block_write data->first_frame_with_data = frame_set->first_frame; memcpy(block->block_contents+offset, &data->first_frame_with_data, sizeof(data->first_frame_with_data)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->first_frame_with_data); memcpy(block->block_contents+offset, &stride_length, sizeof(stride_length)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(stride_length); } @@ -3686,26 +4051,34 @@ static tng_function_status tng_particle_data_block_write memcpy(block->block_contents+offset, &num_first_particle, sizeof(num_first_particle)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(num_first_particle); memcpy(block->block_contents+offset, &n_particles, sizeof(n_particles)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents+offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(n_particles); + /* FIXME: If not using a union to store data a whole dimension or the + * whole block can be written at once if byte swapping is not needed */ switch(data->datatype) { case TNG_FLOAT_DATA: @@ -3721,8 +4094,16 @@ static tng_function_status tng_particle_data_block_write memcpy(block->block_contents+offset, &second_dim_values[k].f, size); - tng_byte_order_to_big_endian_32(tng_data, - (int32_t *)(block->block_contents+offset)); + if(tng_data->output_endianness_swap_func_32) + { + if(tng_data->output_endianness_swap_func_32(tng_data, + (int32_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } + } offset += size; } } @@ -3742,8 +4123,16 @@ static tng_function_status tng_particle_data_block_write memcpy(block->block_contents+offset, &second_dim_values[k].i, size); - tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)); + if(tng_data->output_endianness_swap_func_64) + { + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } + } offset += size; } } @@ -3781,8 +4170,16 @@ static tng_function_status tng_particle_data_block_write memcpy(block->block_contents+offset, &second_dim_values[k].d, size); - tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)); + if(tng_data->output_endianness_swap_func_64) + { + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } + } offset += size; } } @@ -4084,6 +4481,8 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data, n_frames = max(1, n_frames / stride_length); + /* FIXME: If not using a union to store data a whole dimension + * or the whole block can be read at once if byte swapping is not needed */ switch(datatype) { case TNG_FLOAT_DATA: @@ -4093,12 +4492,15 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data, { memcpy(&data->values[i][j].f, block->block_contents+*offset, size); - if(tng_byte_order_to_big_endian_32(tng_data, - (int32_t *) &data->values[i][j]) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_32) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_32(tng_data, + (int32_t *)&data->values[i][j]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } *offset += size; } @@ -4111,12 +4513,15 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data, { memcpy(&data->values[i][j].i, block->block_contents+*offset, size); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *) &data->values[i][j].i) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + (int64_t *)&data->values[i][j]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } *offset += size; } @@ -4154,12 +4559,15 @@ static tng_function_status tng_data_read(tng_trajectory_t tng_data, { memcpy(&data->values[i][j].d, block->block_contents+*offset, size); - if(tng_byte_order_to_big_endian_64(tng_data, - (int64_t *) &data->values[i][j].d) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + (int64_t *)&data->values[i][j]) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } *offset += size; } @@ -4337,25 +4745,29 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data, memcpy(block->block_contents+offset, &data->n_values_per_frame, sizeof(data->n_values_per_frame)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->n_values_per_frame); memcpy(block->block_contents+offset, &data->codec_id, sizeof(data->codec_id)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->codec_id); @@ -4363,13 +4775,15 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data, { memcpy(block->block_contents+offset, &data->compression_multiplier, sizeof(data->compression_multiplier)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->compression_multiplier); } @@ -4381,29 +4795,35 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data, data->first_frame_with_data = frame_set->first_frame; memcpy(block->block_contents+offset, &data->first_frame_with_data, sizeof(data->first_frame_with_data)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->first_frame_with_data); memcpy(block->block_contents+offset, &stride_length, sizeof(data->stride_length)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - (block->block_contents + offset)) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. " - "%s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(data->stride_length); } + /* FIXME: If not using a union to store data a whole dimension or the + * whole block can be written at once if byte swapping is not needed */ switch(data->datatype) { case TNG_FLOAT_DATA: @@ -4413,8 +4833,16 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data, { memcpy(block->block_contents+offset, &data->values[i][j].f, size); - tng_byte_order_to_big_endian_32(tng_data, - (int32_t *)(block->block_contents+offset)); + if(tng_data->output_endianness_swap_func_32) + { + if(tng_data->output_endianness_swap_func_32(tng_data, + (int32_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } + } offset += size; } } @@ -4426,8 +4854,16 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data, { memcpy(block->block_contents+offset, &data->values[i][j].i, size); - tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)); + if(tng_data->output_endianness_swap_func_64) + { + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } + } offset += size; } } @@ -4452,8 +4888,16 @@ static tng_function_status tng_data_block_write(tng_trajectory_t tng_data, { memcpy(block->block_contents+offset, &data->values[i][j].d, size); - tng_byte_order_to_big_endian_64(tng_data, - (int64_t *)(block->block_contents+offset)); + if(tng_data->output_endianness_swap_func_64) + { + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)block->header_contents+offset) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } + } offset += size; } } @@ -4558,19 +5002,29 @@ static tng_function_status tng_data_block_contents_read memcpy(&n_values, block->block_contents+offset, sizeof(n_values)); - if(tng_byte_order_to_big_endian_64(tng_data, &n_values) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &n_values) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(n_values); memcpy(&codec_id, block->block_contents+offset, sizeof(codec_id)); - if(tng_byte_order_to_big_endian_64(tng_data, &codec_id) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &codec_id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(codec_id); @@ -4578,11 +5032,15 @@ static tng_function_status tng_data_block_contents_read { memcpy(&multiplier, block->block_contents+offset, sizeof(multiplier)); - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *)&multiplier) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + (int64_t *) &multiplier) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(multiplier); } @@ -4597,21 +5055,29 @@ static tng_function_status tng_data_block_contents_read { memcpy(&first_frame_with_data, block->block_contents+offset, sizeof(first_frame_with_data)); - if(tng_byte_order_to_big_endian_64(tng_data, &first_frame_with_data) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &first_frame_with_data) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(first_frame_with_data); memcpy(&stride_length, block->block_contents+offset, sizeof(stride_length)); - if(tng_byte_order_to_big_endian_64(tng_data, &stride_length) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &stride_length) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(stride_length); } @@ -4632,22 +5098,30 @@ static tng_function_status tng_data_block_contents_read if (dependency & TNG_PARTICLE_DEPENDENT) { memcpy(&num_first_particle, block->block_contents+offset, - sizeof(num_first_particle)); - if(tng_byte_order_to_big_endian_64(tng_data, &num_first_particle) != - TNG_SUCCESS) + sizeof(num_first_particle)); + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &num_first_particle) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(num_first_particle); memcpy(&block_n_particles, block->block_contents+offset, sizeof(block_n_particles)); - if(tng_byte_order_to_big_endian_64(tng_data, &block_n_particles) != - TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &block_n_particles) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } offset += sizeof(block_n_particles); } @@ -4758,10 +5232,15 @@ static tng_function_status tng_header_pointers_update pos = tng_data->first_trajectory_frame_set_output_file_pos; - if(tng_byte_order_to_big_endian_64(tng_data, &pos) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fwrite(&pos, sizeof(int64_t), 1, tng_data->output_file) != 1) @@ -4772,10 +5251,15 @@ static tng_function_status tng_header_pointers_update pos = tng_data->last_trajectory_frame_set_output_file_pos; - if(tng_byte_order_to_big_endian_64(tng_data, &pos) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fwrite(&pos, @@ -4852,10 +5336,15 @@ static tng_function_status tng_frame_set_pointers_update pos = tng_data->current_trajectory_frame_set_output_file_pos; - if(tng_byte_order_to_big_endian_64(tng_data, &pos) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fwrite(&pos, sizeof(int64_t), 1, tng_data->output_file) != 1) @@ -4898,10 +5387,15 @@ static tng_function_status tng_frame_set_pointers_update pos = tng_data->current_trajectory_frame_set_output_file_pos; - if(tng_byte_order_to_big_endian_64(tng_data, &pos) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fwrite(&pos, sizeof(int64_t), 1, tng_data->output_file) != 1) @@ -4943,10 +5437,15 @@ static tng_function_status tng_frame_set_pointers_update pos = tng_data->current_trajectory_frame_set_output_file_pos; - if(tng_byte_order_to_big_endian_64(tng_data, &pos) != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fwrite(&pos, sizeof(int64_t), 1, tng_data->output_file) != 1) @@ -6060,17 +6559,14 @@ tng_function_status tng_trajectory_init(tng_trajectory_t *tng_data_p) tng_data->endianness_64 = TNG_BYTE_SWAP_64; } - if(tng_data->endianness_32 == TNG_LITTLE_ENDIAN_32 || - tng_data->endianness_64 == TNG_LITTLE_ENDIAN_64) - { - tng_data->input_endianness = TNG_LITTLE_ENDIAN; - tng_data->output_endianness = TNG_LITTLE_ENDIAN; - } - else - { - tng_data->input_endianness = TNG_BIG_ENDIAN; - tng_data->output_endianness = TNG_BIG_ENDIAN; - } + /* By default do not swap the byte order, i.e. keep the byte order of the + * architecture. The input file endianness will be set when reading the + * header. The output endianness can be changed - before the file is + * written. */ + tng_data->input_endianness_swap_func_32 = 0; + tng_data->input_endianness_swap_func_64 = 0; + tng_data->output_endianness_swap_func_32 = 0; + tng_data->output_endianness_swap_func_64 = 0; tng_data->current_trajectory_frame_set.next_frame_set_file_pos = -1; tng_data->current_trajectory_frame_set.prev_frame_set_file_pos = -1; @@ -6421,8 +6917,10 @@ tng_function_status tng_trajectory_init_from_src(tng_trajectory_t src, dest->endianness_32 = src->endianness_32; dest->endianness_64 = src->endianness_64; - dest->input_endianness = src->input_endianness; - dest->output_endianness = src->output_endianness; + dest->input_endianness_swap_func_32 = src->input_endianness_swap_func_32; + dest->input_endianness_swap_func_64 = src->input_endianness_swap_func_64; + dest->output_endianness_swap_func_32 = src->output_endianness_swap_func_32; + dest->output_endianness_swap_func_64 = src->output_endianness_swap_func_64; dest->current_trajectory_frame_set.next_frame_set_file_pos = -1; dest->current_trajectory_frame_set.prev_frame_set_file_pos = -1; @@ -8258,13 +8756,15 @@ tng_function_status tng_frame_set_new(tng_trajectory_t tng_data, return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, - &frame_set-> - medium_stride_prev_frame_set_file_pos) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->medium_stride_prev_frame_set_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } tng_block_destroy(&block); @@ -8314,13 +8814,15 @@ tng_function_status tng_frame_set_new(tng_trajectory_t tng_data, return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, - &frame_set-> - long_stride_prev_frame_set_file_pos) - != TNG_SUCCESS) + if(tng_data->input_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->input_endianness_swap_func_64(tng_data, + &frame_set->long_stride_prev_frame_set_file_pos) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } } @@ -8955,10 +9457,15 @@ tng_function_status tng_frame_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &data.n_values_per_frame) != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &data.n_values_per_frame) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fread(&data.codec_id, sizeof(data.codec_id), 1, @@ -8968,10 +9475,15 @@ tng_function_status tng_frame_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &data.codec_id) != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &data.codec_id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(data.codec_id != TNG_UNCOMPRESSED) @@ -8984,12 +9496,15 @@ tng_function_status tng_frame_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - &data.compression_multiplier) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)&data.compression_multiplier) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } } else @@ -9006,11 +9521,15 @@ tng_function_status tng_frame_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &data.first_frame_with_data) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &data.first_frame_with_data) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fread(&data.stride_length, sizeof(data.stride_length), @@ -9020,11 +9539,15 @@ tng_function_status tng_frame_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &data.stride_length) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &data.stride_length) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } } else @@ -9078,26 +9601,38 @@ tng_function_status tng_frame_data_write(tng_trajectory_t tng_data, /* If the endianness is not big endian the data needs to be swapped */ if((data.datatype == TNG_INT_DATA || data.datatype == TNG_DOUBLE_DATA) && - tng_data->endianness_64 != TNG_BIG_ENDIAN_64) + tng_data->output_endianness_swap_func_64) { copy = malloc(n_values_per_frame * size); memcpy(copy, values, n_values_per_frame * size); for(i = 0; i < n_values_per_frame; i++) { - tng_byte_order_to_big_endian_64(tng_data, (int64_t *)copy+i); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)copy+i) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } fwrite(copy, n_values_per_frame, size, tng_data->output_file); free(copy); } else if(data.datatype == TNG_FLOAT_DATA && - tng_data->endianness_32 != TNG_BIG_ENDIAN_32) + tng_data->output_endianness_swap_func_32) { copy = malloc(n_values_per_frame * size); memcpy(copy, values, n_values_per_frame * size); for(i = 0; i < n_values_per_frame; i++) { - tng_byte_order_to_big_endian_32(tng_data, (int32_t *)copy+i); + if(tng_data->output_endianness_swap_func_32(tng_data, + (int32_t *)copy+i) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } fwrite(copy, n_values_per_frame, size, tng_data->output_file); @@ -9401,11 +9936,15 @@ tng_function_status tng_frame_particle_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &data.n_values_per_frame) - != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &data.n_values_per_frame) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fread(&data.codec_id, sizeof(data.codec_id), 1, @@ -9415,10 +9954,15 @@ tng_function_status tng_frame_particle_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &data.codec_id) != TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &data.codec_id) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(data.codec_id != TNG_UNCOMPRESSED) @@ -9432,12 +9976,15 @@ tng_function_status tng_frame_particle_data_write(tng_trajectory_t tng_data, return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, (int64_t *) - &data.compression_multiplier) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *)&data.compression_multiplier) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } } else @@ -9455,11 +10002,15 @@ tng_function_status tng_frame_particle_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &data.first_frame_with_data) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &data.first_frame_with_data) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fread(&data.stride_length, sizeof(data.stride_length), @@ -9469,11 +10020,15 @@ tng_function_status tng_frame_particle_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &data.stride_length) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &data.stride_length) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } } else @@ -9490,11 +10045,15 @@ tng_function_status tng_frame_particle_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &num_first_particle) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &num_first_particle) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } if(fread(&block_n_particles, sizeof(block_n_particles), 1, @@ -9504,11 +10063,15 @@ tng_function_status tng_frame_particle_data_write(tng_trajectory_t tng_data, tng_block_destroy(&block); return(TNG_CRITICAL); } - if(tng_byte_order_to_big_endian_64(tng_data, &block_n_particles) != - TNG_SUCCESS) + if(tng_data->output_endianness_swap_func_64) { - printf("Cannot swap byte order to get big endian. %s: %d\n", - __FILE__, __LINE__); + if(tng_data->output_endianness_swap_func_64(tng_data, + &block_n_particles) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } @@ -9557,26 +10120,38 @@ tng_function_status tng_frame_particle_data_write(tng_trajectory_t tng_data, /* If the endianness is not big endian the data needs to be swapped */ if((data.datatype == TNG_INT_DATA || data.datatype == TNG_DOUBLE_DATA) && - tng_data->endianness_64 != TNG_BIG_ENDIAN_64) + tng_data->output_endianness_swap_func_64) { copy = malloc(val_n_particles * n_values_per_frame * size); memcpy(copy, values, val_n_particles * n_values_per_frame * size); for(i = 0; i < val_n_particles * n_values_per_frame; i++) { - tng_byte_order_to_big_endian_64(tng_data, (int64_t *)copy+i); + if(tng_data->output_endianness_swap_func_64(tng_data, + (int64_t *) copy+i) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } fwrite(copy, val_n_particles * n_values_per_frame, size, tng_data->output_file); free(copy); } else if(data.datatype == TNG_FLOAT_DATA && - tng_data->endianness_32 != TNG_BIG_ENDIAN_32) + tng_data->output_endianness_swap_func_32) { copy = malloc(val_n_particles * n_values_per_frame * size); memcpy(copy, values, val_n_particles * n_values_per_frame * size); for(i = 0; i < val_n_particles * n_values_per_frame; i++) { - tng_byte_order_to_big_endian_32(tng_data, (int32_t *)copy+i); + if(tng_data->output_endianness_swap_func_32(tng_data, + (int32_t *) copy+i) + != TNG_SUCCESS) + { + printf("Cannot swap byte order. %s: %d\n", + __FILE__, __LINE__); + } } fwrite(copy, val_n_particles * n_values_per_frame, size, tng_data->output_file); diff --git a/src/lib/tng_io.h b/src/lib/tng_io.h index b2d07ff..9fa13b2 100644 --- a/src/lib/tng_io.h +++ b/src/lib/tng_io.h @@ -228,7 +228,7 @@ #include <inttypes.h> /** The version of this TNG build */ -#define TNG_VERSION 1 +#define TNG_VERSION 2 /** Flag to indicate frame dependent data. */ #define TNG_FRAME_DEPENDENT 1 |