TNG version 1.7.6

Fixed bug with reading and writing TNG compressed blocks
on big endian platforms.
Fixed compiler warning about potentially uninitialized values.

Fixes #1725.

Change-Id: I92062492116fa3044c3d1d0d0f920cfe42d21cbe

diff --git a/src/external/tng_io/BuildTNG.cmake b/src/external/tng_io/BuildTNG.cmake
index 38a86c61c4787908513050522dd9901d2adb62ee..5a7432cd8289df56f68625fa951699dae6e8287c 100644 (file)
--- a/src/external/tng_io/BuildTNG.cmake
+++ b/src/external/tng_io/BuildTNG.cmake
@@ -5,7 +5,7 @@ set(TNG_ROOT_BINARY_DIR ${CMAKE_BINARY_DIR}/${TNG_ROOT_BINARY_DIR})
 function (TNG_GENERATE_VERSION_H)
     set(TNG_MAJOR_VERSION "1")
     set(TNG_MINOR_VERSION "7")
-    set(TNG_VERSION_PATCH_LEVEL "5")
+    set(TNG_VERSION_PATCH_LEVEL "6")
     set(TNG_IO_VERSION "${TNG_MAJOR_VERSION}.${TNG_MINOR_VERSION}.${TNG_VERSION_PATCH_LEVEL}")
     set(TNG_API_VERSION "7")
     configure_file(${TNG_ROOT_SOURCE_DIR}/include/tng/version.h.in

diff --git a/src/external/tng_io/src/lib/tng_io.c b/src/external/tng_io/src/lib/tng_io.c
index 6ac939c208e8387b1e9e10f6b3be383724feb5e7..f0ed8d60b7768799f3312c7f8390fb2db1c3deed 100644 (file)
--- a/src/external/tng_io/src/lib/tng_io.c
+++ b/src/external/tng_io/src/lib/tng_io.c
@@ -5611,41 +5611,46 @@ static tng_function_status tng_data_read(const tng_trajectory_t tng_data,
         {
             memcpy(data->values, contents, full_data_len);
         }
-        switch(datatype)
+        /* Endianness is handled by the TNG compression library. TNG compressed blocks are always written
+         * as little endian by the compression library. */
+        if(codec_id != TNG_TNG_COMPRESSION)
         {
-        case TNG_FLOAT_DATA:
-            if(tng_data->input_endianness_swap_func_32)
+            switch(datatype)
             {
-                for(i = 0; i < full_data_len; i+=size)
+            case TNG_FLOAT_DATA:
+                if(tng_data->input_endianness_swap_func_32)
                 {
-                    if(tng_data->input_endianness_swap_func_32(tng_data,
-                        (int32_t *)((char *)data->values + i))
-                        != TNG_SUCCESS)
+                    for(i = 0; i < full_data_len; i+=size)
                     {
-                        fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                __FILE__, __LINE__);
+                        if(tng_data->input_endianness_swap_func_32(tng_data,
+                            (int32_t *)((char *)data->values + i))
+                            != TNG_SUCCESS)
+                        {
+                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                    __FILE__, __LINE__);
+                        }
                     }
                 }
-            }
-            break;
-        case TNG_INT_DATA:
-        case TNG_DOUBLE_DATA:
-            if(tng_data->input_endianness_swap_func_64)
-            {
-                for(i = 0; i < full_data_len; i+=size)
+                break;
+            case TNG_INT_DATA:
+            case TNG_DOUBLE_DATA:
+                if(tng_data->input_endianness_swap_func_64)
                 {
-                    if(tng_data->input_endianness_swap_func_64(tng_data,
-                        (int64_t *)((char *)data->values + i))
-                        != TNG_SUCCESS)
+                    for(i = 0; i < full_data_len; i+=size)
                     {
-                        fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                __FILE__, __LINE__);
+                        if(tng_data->input_endianness_swap_func_64(tng_data,
+                            (int64_t *)((char *)data->values + i))
+                            != TNG_SUCCESS)
+                        {
+                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                    __FILE__, __LINE__);
+                        }
                     }
                 }
+                break;
+            case TNG_CHAR_DATA:
+                break;
             }
-            break;
-        case TNG_CHAR_DATA:
-            break;
         }
     }
 
@@ -6030,103 +6035,106 @@ static tng_function_status tng_data_block_write(const tng_trajectory_t tng_data,
         if(data->values)
         {
             memcpy(contents, data->values, full_data_len);
-            switch(data->datatype)
+            /* If writing TNG compressed data the endianness is taken into account by the compression
+             * routines. TNG compressed data is always written as little endian. */
+            if(data->codec_id != TNG_TNG_COMPRESSION)
             {
-            case TNG_FLOAT_DATA:
-                if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
-                   data->codec_id == TNG_TNG_COMPRESSION)
+                switch(data->datatype)
                 {
-                    if(tng_data->output_endianness_swap_func_32)
+                case TNG_FLOAT_DATA:
+                    if(data->codec_id == TNG_UNCOMPRESSED || data->codec_id == TNG_GZIP_COMPRESSION)
                     {
-                        for(i = 0; i < full_data_len; i+=size)
+                        if(tng_data->output_endianness_swap_func_32)
                         {
-                            if(tng_data->output_endianness_swap_func_32(tng_data,
-                               (int32_t *)(contents + i))
-                               != TNG_SUCCESS)
+                            for(i = 0; i < full_data_len; i+=size)
                             {
-                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                        __FILE__, __LINE__);
+                                if(tng_data->output_endianness_swap_func_32(tng_data,
+                                (int32_t *)(contents + i))
+                                != TNG_SUCCESS)
+                                {
+                                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                            __FILE__, __LINE__);
+                                }
                             }
                         }
                     }
-                }
-                else
-                {
-                    multiplier = data->compression_multiplier;
-                    if(fabs(multiplier - 1.0) > 0.00001 ||
-                       tng_data->output_endianness_swap_func_32)
+                    else
                     {
-                        for(i = 0; full_data_len; i+=size)
+                        multiplier = data->compression_multiplier;
+                        if(fabs(multiplier - 1.0) > 0.00001 ||
+                        tng_data->output_endianness_swap_func_32)
                         {
-                            *(float *)(contents + i) *= (float)multiplier;
-                            if(tng_data->output_endianness_swap_func_32 &&
-                            tng_data->output_endianness_swap_func_32(tng_data,
-                            (int32_t *)(contents + i))
-                            != TNG_SUCCESS)
+                            for(i = 0; full_data_len; i+=size)
                             {
-                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                        __FILE__, __LINE__);
+                                *(float *)(contents + i) *= (float)multiplier;
+                                if(tng_data->output_endianness_swap_func_32 &&
+                                tng_data->output_endianness_swap_func_32(tng_data,
+                                (int32_t *)(contents + i))
+                                != TNG_SUCCESS)
+                                {
+                                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                            __FILE__, __LINE__);
+                                }
                             }
                         }
                     }
-                }
-                break;
-            case TNG_INT_DATA:
-                if(tng_data->output_endianness_swap_func_64)
-                {
-                    for(i = 0; i < full_data_len; i+=size)
-                    {
-                        if(tng_data->output_endianness_swap_func_64(tng_data,
-                           (int64_t *)(contents + i))
-                           != TNG_SUCCESS)
-                        {
-                            fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                    __FILE__, __LINE__);
-                        }
-                    }
-                }
-                break;
-            case TNG_DOUBLE_DATA:
-                if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION ||
-                   data->codec_id == TNG_TNG_COMPRESSION)
-                {
+                    break;
+                case TNG_INT_DATA:
                     if(tng_data->output_endianness_swap_func_64)
                     {
                         for(i = 0; i < full_data_len; i+=size)
                         {
                             if(tng_data->output_endianness_swap_func_64(tng_data,
-                               (int64_t *)(contents + i))
-                               != TNG_SUCCESS)
+                            (int64_t *)(contents + i))
+                            != TNG_SUCCESS)
                             {
                                 fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
                                         __FILE__, __LINE__);
                             }
                         }
                     }
-                }
-                else
-                {
-                    multiplier = data->compression_multiplier;
-                    if(fabs(multiplier - 1.0) > 0.00001 ||
-                       tng_data->output_endianness_swap_func_64)
+                    break;
+                case TNG_DOUBLE_DATA:
+                    if(data->codec_id == TNG_UNCOMPRESSED || data-> codec_id == TNG_GZIP_COMPRESSION)
                     {
-                        for(i = 0; i < full_data_len; i+=size)
+                        if(tng_data->output_endianness_swap_func_64)
                         {
-                            *(double *)(contents + i) *= multiplier;
-                            if(tng_data->output_endianness_swap_func_64 &&
-                            tng_data->output_endianness_swap_func_64(tng_data,
-                            (int64_t *)(contents + i))
-                            != TNG_SUCCESS)
+                            for(i = 0; i < full_data_len; i+=size)
                             {
-                                fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
-                                        __FILE__, __LINE__);
+                                if(tng_data->output_endianness_swap_func_64(tng_data,
+                                (int64_t *)(contents + i))
+                                != TNG_SUCCESS)
+                                {
+                                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                            __FILE__, __LINE__);
+                                }
                             }
                         }
                     }
+                    else
+                    {
+                        multiplier = data->compression_multiplier;
+                        if(fabs(multiplier - 1.0) > 0.00001 ||
+                        tng_data->output_endianness_swap_func_64)
+                        {
+                            for(i = 0; i < full_data_len; i+=size)
+                            {
+                                *(double *)(contents + i) *= multiplier;
+                                if(tng_data->output_endianness_swap_func_64 &&
+                                tng_data->output_endianness_swap_func_64(tng_data,
+                                (int64_t *)(contents + i))
+                                != TNG_SUCCESS)
+                                {
+                                    fprintf(stderr, "TNG library: Cannot swap byte order. %s: %d\n",
+                                            __FILE__, __LINE__);
+                                }
+                            }
+                        }
+                    }
+                    break;
+                case TNG_CHAR_DATA:
+                    break;
                 }
-                break;
-            case TNG_CHAR_DATA:
-                break;
             }
         }
         else
@@ -6148,7 +6156,7 @@ static tng_function_status tng_data_block_write(const tng_trajectory_t tng_data,
                                 &contents, &block_data_len);
             if(stat != TNG_SUCCESS)
             {
-                fprintf(stderr, "TNG library: Could not write tng compressed block data. %s: %d\n",
+                fprintf(stderr, "TNG library: Could not write TNG compressed block data. %s: %d\n",
                     __FILE__, __LINE__);
                 if(stat == TNG_CRITICAL)
                 {
@@ -15222,26 +15230,24 @@ tng_function_status DECLSPECDLLEXPORT tng_util_trajectory_open
         return(TNG_CRITICAL);
     }
 
-    if(mode == 'r' || mode == 'a')
+    if(mode == 'w')
     {
-        tng_input_file_set(*tng_data_p, filename);
-
-        /* Read the file headers */
-        tng_file_headers_read(*tng_data_p, TNG_USE_HASH);
+        stat = tng_output_file_set(*tng_data_p, filename);
+        return(stat);
+    }
+    tng_input_file_set(*tng_data_p, filename);
 
-        stat = tng_num_frame_sets_get(*tng_data_p, &(*tng_data_p)->n_trajectory_frame_sets);
+    /* Read the file headers */
+    tng_file_headers_read(*tng_data_p, TNG_USE_HASH);
 
-        if(stat != TNG_SUCCESS)
-        {
-            return(stat);
-        }
-    }
+    stat = tng_num_frame_sets_get(*tng_data_p, &(*tng_data_p)->n_trajectory_frame_sets);
 
-    if(mode == 'w')
+    if(stat != TNG_SUCCESS)
     {
-        stat = tng_output_file_set(*tng_data_p, filename);
+        return(stat);
     }
-    else if(mode == 'a')
+
+    if(mode == 'a')
     {
         if((*tng_data_p)->output_file)
         {