libgta: deprecate compression for new version 1.2.0.
authorMartin Lambers <marlam@marlam.de>
Mon, 26 Aug 2019 08:13:30 +0000 (10:13 +0200)
committerMartin Lambers <marlam@marlam.de>
Mon, 26 Aug 2019 08:13:30 +0000 (10:13 +0200)
New files are always created without compression. Reading old files with
compression is only supported if the library is build with the
--with-compression configure option.

Building with CMake is now recommended over building with autoconf because CMake
module files will be generated and installed. Note that building with CMake only
supports the new default configuration with disabled compression.

In the future, both compression and autoconf support will be removed.

23 files changed:
libgta/CMakeLists.txt
libgta/Makefile.am
libgta/NEWS
libgta/README
libgta/cmake/FindGTA.cmake [deleted file]
libgta/configure.ac
libgta/doc/example-basic.c
libgta/doc/example-basic.cpp
libgta/doc/example-stream-io.c
libgta/doc/example-stream-io.cpp
libgta/libgtaConfig.cmake.in [new file with mode: 0644]
libgta/src/Makefile.am
libgta/src/gta.c
libgta/src/gta/gta.h
libgta/src/gta/gta.hpp
libgta/tests/Makefile.am
libgta/tests/basic.c
libgta/tests/compression.c [deleted file]
libgta/tests/elements.c
libgta/tests/endianness.c
libgta/tests/fuzztest-check.c
libgta/tests/fuzztest-create.c
libgta/tests/taglists.c

index 75a8fbe..76ba25f 100644 (file)
@@ -1,11 +1,11 @@
-# Copyright (C) 2014, 2015, 2016, 2018
+# Copyright (C) 2014, 2015, 2016, 2018, 2019
 # Martin Lambers <marlam@marlam.de>
 #
 # Copying and distribution of this file, with or without modification, are
 # permitted in any medium without royalty provided the copyright notice and this
 # notice are preserved. This file is offered as-is, without any warranty.
 
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 3.5)
 include(CheckTypeSize)
 
 project(libgta C)
@@ -17,12 +17,12 @@ option(GTA_BUILD_DOCUMENTATION "Build API reference documentation (requires Doxy
 
 # libgta version
 set(GTA_VERSION_MAJOR "1")
-set(GTA_VERSION_MINOR "0")
-set(GTA_VERSION_PATCH "9")
-set(GTA_VERSION 1.0.9)
-set(GTA_VERSION_NUMBER 0x010009)
-set(GTA_LIB_VERSION "0.0.4")
-set(GTA_LIB_SOVERSION "0")
+set(GTA_VERSION_MINOR "2")
+set(GTA_VERSION_PATCH "0")
+set(GTA_VERSION 1.2.0)
+set(GTA_VERSION_NUMBER 0x010200)
+set(GTA_LIB_VERSION "1.0.0")
+set(GTA_LIB_SOVERSION "1")
 
 # Autoconf compatibility
 set(PACKAGE_NAME "${PROJECT_NAME}")       # required by doxyfile.in
@@ -35,21 +35,12 @@ file(WRITE "${CMAKE_BINARY_DIR}/src/config.h" "/* generated from CMakeLists.txt
 file(APPEND "${CMAKE_BINARY_DIR}/src/config.h" "#define SIZEOF_INT ${SIZEOF_INT}\n")
 file(APPEND "${CMAKE_BINARY_DIR}/src/config.h" "#define SIZEOF_INT8_T ${SIZEOF_INT8_T}\n")
 
-# Compiler setup
-if(CMAKE_COMPILER_IS_GNUCC)
-  add_definitions(-std=gnu99)
-endif()
-
 # Main target: libgta
-find_package(ZLIB REQUIRED)
-find_package(BZip2 REQUIRED)
-find_package(LibLZMA REQUIRED)
 configure_file("${CMAKE_SOURCE_DIR}/src/gta/gta_version.h.in" "${CMAKE_BINARY_DIR}/src/gta/gta_version.h" @ONLY)
-include_directories("${ZLIB_INCLUDE_DIRS}" "${BZIP2_INCLUDE_DIR}" "${LIBLZMA_INCLUDE_DIRS}"
-  "${CMAKE_SOURCE_DIR}/src" "${CMAKE_BINARY_DIR}/src")
+include_directories("${CMAKE_SOURCE_DIR}/src" "${CMAKE_BINARY_DIR}/src")
 if(GTA_BUILD_SHARED_LIB)
   add_library(libgta_shared SHARED src/gta.c src/gta/gta.h src/gta/gta_version.h)
-  target_link_libraries(libgta_shared ${ZLIB_LIBRARIES} ${BZIP2_LIBRARIES} ${LIBLZMA_LIBRARIES})
+  set_property(TARGET libgta_shared PROPERTY C_STANDARD 99)
   set_target_properties(libgta_shared PROPERTIES DEFINE_SYMBOL DLL_EXPORT)
   set_target_properties(libgta_shared PROPERTIES OUTPUT_NAME gta)
   set_target_properties(libgta_shared PROPERTIES VERSION ${GTA_LIB_VERSION})
@@ -62,6 +53,7 @@ if(GTA_BUILD_SHARED_LIB)
 endif()
 if(GTA_BUILD_STATIC_LIB)
   add_library(libgta_static STATIC src/gta.c src/gta/gta.h src/gta/gta_version.h)
+  set_property(TARGET libgta_static PROPERTY C_STANDARD 99)
   set_target_properties(libgta_static PROPERTIES OUTPUT_NAME gta)
   install(TARGETS libgta_static
     RUNTIME DESTINATION bin
@@ -75,13 +67,28 @@ set(prefix "${CMAKE_INSTALL_PREFIX}")
 set(exec_prefix "\${prefix}")
 set(libdir "\${exec_prefix}/lib${LIB_SUFFIX}")
 set(includedir "\${prefix}/include")
-set(GTA_PKGCONFIG_LIBRARIES_PRIVATE "")
-foreach(GTA_PKGCONFIG_LIBRARY_PRIV ${LIBLZMA_LIBRARIES} ${BZIP2_LIBRARIES} ${ZLIB_LIBRARIES})
-   set(GTA_PKGCONFIG_LIBRARIES_PRIVATE "${GTA_PKGCONFIG_LIBRARIES_PRIVATE} -l${GTA_PKGCONFIG_LIBRARY_PRIV}")
-endforeach()
-set(LTLIBLZMA ${GTA_PKGCONFIG_LIBRARIES_PRIVATE}) # for compatibility for libtool; see gta.pc.in
 configure_file("${CMAKE_SOURCE_DIR}/src/gta.pc.in" "${CMAKE_BINARY_DIR}/src/gta.pc" @ONLY)
 install(FILES "${CMAKE_BINARY_DIR}/src/gta.pc" DESTINATION lib${LIB_SUFFIX}/pkgconfig)
+# CMake module files
+include(CMakePackageConfigHelpers)
+set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/include)
+set(LIB_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX})
+configure_package_config_file(
+    libgtaConfig.cmake.in ${CMAKE_BINARY_DIR}/libgtaConfig.cmake
+    INSTALL_DESTINATION lib${LIB_SUFFIX}/cmake/libgta-{GTA_VERSION}
+    PATH_VARS INCLUDE_INSTALL_DIR LIB_INSTALL_DIR
+    NO_CHECK_REQUIRED_COMPONENTS_MACRO
+)
+write_basic_package_version_file(
+    ${CMAKE_BINARY_DIR}/libgtaConfigVersion.cmake
+    VERSION ${GTA_VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+install(FILES
+    ${CMAKE_BINARY_DIR}/libgtaConfig.cmake
+    ${CMAKE_BINARY_DIR}/libgtaConfigVersion.cmake
+    DESTINATION ${LIB_INSTALL_DIR}/cmake/libgta-${GTA_VERSION}
+)
 
 # Optional target: reference documentation
 if(GTA_BUILD_DOCUMENTATION)
@@ -96,7 +103,6 @@ if(GTA_BUILD_DOCUMENTATION)
   )
   add_custom_target(doc ALL DEPENDS "${CMAKE_BINARY_DIR}/doc/reference/index.html")
   install(DIRECTORY "${CMAKE_BINARY_DIR}/doc/reference" DESTINATION share/doc/libgta)
-  install(FILES "${CMAKE_SOURCE_DIR}/cmake/FindGTA.cmake" DESTINATION share/libgta/cmake)
 endif()
 
 # Extra target: 'make dist' for making
index f390439..46bd8ad 100644 (file)
@@ -7,10 +7,7 @@
 
 SUBDIRS = doc src tests
 
-EXTRA_DIST = CMakeLists.txt cmake/FindGTA.cmake
-
-cmakedir = $(datadir)/$(PACKAGE)/cmake
-cmake_DATA = cmake/FindGTA.cmake
+EXTRA_DIST = CMakeLists.txt libgtaConfig.cmake.in
 
 fuzztest:
        $(MAKE) -C tests fuzztest
index e69de29..7e8ce1d 100644 (file)
@@ -0,0 +1,9 @@
+Version 1.2.0:
+- Compression is now deprecated. The library is built without support for
+  compression by default and cannot read compressed GTA files. You can enable
+  compression with the --with-compression configure option to be able to read
+  compressed GTA files, but even then the library will write all files
+  uncompressed.
+- Building with the autoconf configure script is now deprecated. It is still
+  supported, but will be removed in a future version. Building with CMake is
+  recommended.
index a709fd4..eef3920 100644 (file)
@@ -5,9 +5,7 @@ format. This file format has the following features:
 * GTAs can optionally use simple tags to store rich metadata
 * GTAs are streamable, which allows direct reading from and writing to pipes,
   network sockets, and other non-seekable media
-* GTAs can use ZLIB, BZIP2, or XZ compression, allowing a tradeoff between
-  compression/decompression speed and compression ratio
-* Uncompressed GTA files allow easy out-of-core data access for very large
+* GTA files allow easy out-of-core data access for very large
   arrays
 
 See https://marlam.de/gta for more information.
diff --git a/libgta/cmake/FindGTA.cmake b/libgta/cmake/FindGTA.cmake
deleted file mode 100644 (file)
index b6c61f5..0000000
+++ /dev/null
@@ -1,58 +0,0 @@
-# - Try to find the GTA library (libgta)
-#
-# Once done this will define
-#
-#  GTA_FOUND - System has libgta
-#  GTA_INCLUDE_DIR - The libgta include directory
-#  GTA_LIBRARIES - The libraries needed to use libgta
-
-# Adapted from FindGnuTLS.cmake 2012-12-06, Martin Lambers.
-# Original copyright notice:
-#=============================================================================
-# Copyright 2009 Kitware, Inc.
-# Copyright 2009 Philip Lowman <philip@yhbt.com>
-# Copyright 2009 Brad Hards <bradh@kde.org>
-# Copyright 2006 Alexander Neundorf <neundorf@kde.org>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-
-IF(GTA_INCLUDE_DIR AND GTA_LIBRARY)
-    # in cache already
-    SET(GTA_FIND_QUIETLY TRUE)
-ENDIF(GTA_INCLUDE_DIR AND GTA_LIBRARY)
-
-FIND_PACKAGE(PkgConfig QUIET)
-IF(PKG_CONFIG_FOUND)
-    # try using pkg-config to get the directories and then use these values
-    # in the FIND_PATH() and FIND_LIBRARY() calls
-    PKG_CHECK_MODULES(PC_GTA QUIET gta)
-    SET(GTA_VERSION_STRING ${PC_GTA_VERSION})
-ENDIF()
-
-FIND_PATH(GTA_INCLUDE_DIR gta/gta.h HINTS ${PC_GTA_INCLUDE_DIRS})
-
-FIND_LIBRARY(GTA_LIBRARY NAMES gta libgta HINTS ${PC_GTA_LIBRARY_DIRS})
-
-MARK_AS_ADVANCED(GTA_INCLUDE_DIR GTA_LIBRARY)
-
-# handle the QUIETLY and REQUIRED arguments and set GTA_FOUND to TRUE if 
-# all listed variables are TRUE
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTA
-    REQUIRED_VARS GTA_LIBRARY GTA_INCLUDE_DIR
-    VERSION_VAR GTA_VERSION_STRING
-)
-
-IF(GTA_FOUND)
-    SET(GTA_LIBRARIES ${GTA_LIBRARY})
-    SET(GTA_INCLUDE_DIRS ${GTA_INCLUDE_DIR})
-ENDIF()
index f6652ba..72fa167 100644 (file)
@@ -5,7 +5,7 @@ dnl
 dnl This file is part of libgta, a library that implements the Generic Tagged
 dnl Array (GTA) file format.
 dnl
-dnl Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2018
+dnl Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2018, 2019
 dnl Martin Lambers <marlam@marlam.de>
 dnl
 dnl Libgta is free software: you can redistribute it and/or modify it under the
@@ -23,7 +23,7 @@ dnl along with Libgta. If not, see <http://www.gnu.org/licenses/>.
 
 dnl Autotools init stuff
 AC_PREREQ([2.65])
-AC_INIT([libgta], [1.0.9], [marlam@marlam.de], [libgta], [https://marlam.de/gta])
+AC_INIT([libgta], [1.2.0], [marlam@marlam.de], [libgta], [https://marlam.de/gta])
 AC_CONFIG_SRCDIR([src/gta.c])
 AC_CONFIG_AUX_DIR([build-aux])
 AC_CONFIG_MACRO_DIR([m4])
@@ -72,27 +72,31 @@ AC_SYS_LARGEFILE
 AC_C_BIGENDIAN
 
 dnl Compression libraries
-AC_LIB_HAVE_LINKFLAGS([z], [], [#include <zlib.h>], [zlibVersion();])
-if test "$HAVE_LIBZ" != "yes"; then
-    AC_MSG_WARN([libz not found])
-    AC_MSG_WARN([libz is provided by zlib; Debian package: libz-dev])
-fi
-AC_LIB_HAVE_LINKFLAGS([bz2], [],
-    [#define BZ_IMPORT
-     #include <bzlib.h>],
-    [BZ2_bzlibVersion();])
-if test "$HAVE_LIBBZ2" != "yes"; then
-    AC_MSG_WARN([libbz2 not found])
-    AC_MSG_WARN([libbz2 is provided by bzip2; Debian package: libbz2-dev])
-fi
-AC_LIB_HAVE_LINKFLAGS([lzma], [], [#include <lzma.h>], [lzma_version_string();])
-if test "$HAVE_LIBLZMA" != "yes"; then
-    AC_MSG_WARN([liblzma not found])
-    AC_MSG_WARN([liblzma is provided by xz; Debian package: liblzma-dev])
-fi
-if test "$HAVE_LIBZ" != "yes" -o "$HAVE_LIBBZ2" != "yes" -o "$HAVE_LIBLZMA" != "yes"; then
-    AC_MSG_ERROR([Required libraries were not found. See messages above.])
+AC_ARG_WITH([compression],
+    [AS_HELP_STRING([--with-compression], [Enable the deprecated compression feature for backward compatibility.])],
+    [if test "$withval" = "yes"; then compression="yes"; else compression="no "; fi], [compression="no "])
+if test "$compression" = "yes"; then
+    AC_LIB_HAVE_LINKFLAGS([z], [], [#include <zlib.h>], [zlibVersion();])
+    if test "$HAVE_LIBZ" != "yes"; then
+        AC_MSG_WARN([libz not found])
+    fi
+    AC_LIB_HAVE_LINKFLAGS([bz2], [],
+        [#define BZ_IMPORT
+         #include <bzlib.h>],
+        [BZ2_bzlibVersion();])
+    if test "$HAVE_LIBBZ2" != "yes"; then
+        AC_MSG_WARN([libbz2 not found])
+    fi
+    AC_LIB_HAVE_LINKFLAGS([lzma], [], [#include <lzma.h>], [lzma_version_string();])
+    if test "$HAVE_LIBLZMA" != "yes"; then
+        AC_MSG_WARN([liblzma not found])
+    fi
+    if test "$HAVE_LIBZ" != "yes" -o "$HAVE_LIBBZ2" != "yes" -o "$HAVE_LIBLZMA" != "yes"; then
+        AC_MSG_ERROR([Required compression libraries were not found. See messages above.])
+    fi
 fi
+AC_DEFINE_UNQUOTED([WITH_COMPRESSION], [`if test "$compression" = "yes"; then echo "1"; else echo "0"; fi`], [Enable compression?])
+AM_CONDITIONAL([WITH_COMPRESSION], [test "$compression" = "yes"])
 
 dnl libgta package version
 AC_SUBST([GTA_VERSION], [$PACKAGE_VERSION])
@@ -108,8 +112,8 @@ dnl Library code modified:            REVISION++
 dnl Interfaces changed/added/removed: CURRENT++ REVISION=0
 dnl Interfaces added:                 AGE++
 dnl Interfaces removed:               AGE=0
-AC_SUBST([LT_CURRENT], [0])
-AC_SUBST([LT_REVISION], [4])
+AC_SUBST([LT_CURRENT], [1])
+AC_SUBST([LT_REVISION], [0])
 AC_SUBST([LT_AGE], [0])
 
 dnl Sanity checks for type sizes
index 1c76eda..9bf1049 100644 (file)
@@ -66,7 +66,6 @@ int main(void)
     if (!f) {
         return 1;
     }
-    gta_set_compression(header, GTA_BZIP2);
     r = gta_write_header_to_stream(header, f);
     if (r != GTA_OK) {
         return 1;
index fa01c23..eb7b828 100644 (file)
@@ -35,7 +35,6 @@ int main(void)
 
         /* Write the GTA to a file */
         std::ofstream ofs("rgb.gta", std::ios::out | std::ios::binary);
-        header.set_compression(gta::bzip2);
         header.write_to(ofs);
         header.write_data(ofs, &(data[0]));
         ofs.close();
index 852e45e..62d7969 100644 (file)
@@ -58,8 +58,6 @@ int main(void)
     if (r != GTA_OK) {
         return 1;
     }
-    /* In this example, the output GTA is always uncompressed */
-    gta_set_compression(outheader, GTA_NONE);
     r = gta_write_header_to_stream(outheader, outfile);
     if (r != GTA_OK) {
         return 1;
index 0392838..5c36232 100644 (file)
@@ -28,8 +28,6 @@ int main(void)
         /* Copy the GTA header */
         inheader.read_from(instream);
         outheader = inheader;
-        /* In this example, the output GTA is always uncompressed */
-        outheader.set_compression(gta::none);
         outheader.write_to(outstream);
 
         /* Copy the array data */
diff --git a/libgta/libgtaConfig.cmake.in b/libgta/libgtaConfig.cmake.in
new file mode 100644 (file)
index 0000000..4a6e7cc
--- /dev/null
@@ -0,0 +1,5 @@
+set(GTA_VERSION @GTA_VERSION@)
+@PACKAGE_INIT@
+set_and_check(GTA_INCLUDE_DIRS "@PACKAGE_INCLUDE_INSTALL_DIR@")
+set_and_check(GTA_LIBRARY_DIRS "@PACKAGE_LIB_INSTALL_DIR@")
+set(GTA_LIBRARIES gta)
index 8fdc193..5932514 100644 (file)
@@ -9,7 +9,9 @@ lib_LTLIBRARIES = libgta.la
 nobase_include_HEADERS = gta/gta_version.h gta/gta.h gta/gta.hpp
 libgta_la_SOURCES = gta.c
 libgta_la_LDFLAGS = -version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE) -no-undefined
+if WITH_COMPRESSION
 libgta_la_LIBADD = $(LTLIBLZMA) $(LTLIBBZ2) $(LTLIBZ)
+endif
 AM_CPPFLAGS = -I$(top_builddir)/src
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = gta.pc
index d1d753c..d54920f 100644 (file)
@@ -4,7 +4,7 @@
  * This file is part of libgta, a library that implements the Generic Tagged
  * Array (GTA) file format.
  *
- * Copyright (C) 2010, 2011, 2012, 2014
+ * Copyright (C) 2010, 2011, 2012, 2014, 2019
  * Martin Lambers <marlam@marlam.de>
  *
  * Libgta is free software: you can redistribute it and/or modify it under the
@@ -407,6 +407,7 @@ gta_compress(void **dst, size_t *dst_size, const void *src, size_t src_size, gta
         }
         break;
 
+#if WITH_COMPRESSION
     case GTA_ZLIB:
     case GTA_ZLIB1:
     case GTA_ZLIB2:
@@ -578,6 +579,7 @@ gta_compress(void **dst, size_t *dst_size, const void *src, size_t src_size, gta
             lzma_end(&strm);
         }
         break;
+#endif
     }
 
     return retval;
@@ -602,6 +604,7 @@ gta_uncompress(void *dst, size_t dst_size, const void *src, size_t src_size, gta
         }
         break;
 
+#if WITH_COMPRESSION
     case GTA_ZLIB:
     case GTA_ZLIB1:
     case GTA_ZLIB2:
@@ -718,6 +721,7 @@ gta_uncompress(void *dst, size_t dst_size, const void *src, size_t src_size, gta
             lzma_end(&strm);
         }
         break;
+#endif
     }
 
     return retval;
@@ -1033,6 +1037,7 @@ gta_read_chunk(const gta_header_t *GTA_RESTRICT header,
     }
     else
     {
+#if WITH_COMPRESSION
         r = read_fn(userdata, &size_compressed, sizeof(uint64_t), &error);
         if (error)
         {
@@ -1085,6 +1090,10 @@ gta_read_chunk(const gta_header_t *GTA_RESTRICT header,
         }
         free(chunk_compressed);
         chunk_compressed = NULL;
+#else
+        retval = GTA_UNSUPPORTED_DATA;
+        goto exit;
+#endif
     }
 
 exit:
@@ -1198,6 +1207,7 @@ gta_skip_chunk(const gta_header_t *GTA_RESTRICT header, size_t *chunk_size,
     }
     else
     {
+#if WITH_COMPRESSION
         r = read_fn(userdata, &size_compressed, sizeof(uint64_t), &error);
         if (error)
         {
@@ -1242,6 +1252,10 @@ gta_skip_chunk(const gta_header_t *GTA_RESTRICT header, size_t *chunk_size,
                 goto exit;
             }
         }
+#else
+        retval = GTA_UNSUPPORTED_DATA;
+        goto exit;
+#endif
     }
 
 exit:
@@ -1271,9 +1285,6 @@ gta_write_chunk(const gta_header_t *GTA_RESTRICT header,
     int error = false;
     uint64_t size_uncompressed = chunk_size;
     uint8_t output_compression;
-    uint64_t size_compressed;
-    void *compressed = NULL;
-    size_t compressed_size = 0;
     gta_result_t retval = GTA_OK;
     size_t r;
 
@@ -1298,29 +1309,7 @@ gta_write_chunk(const gta_header_t *GTA_RESTRICT header,
         retval = GTA_OK;
         goto exit;
     }
-    if (header->compression == GTA_NONE)
-    {
-        output_compression = GTA_NONE;
-    }
-    else
-    {
-        retval = gta_compress(&compressed, &compressed_size,
-                chunk, chunk_size, header->compression);
-        if (retval != GTA_OK)
-        {
-            goto exit;
-        }
-        if (compressed_size + sizeof(uint64_t) >= chunk_size)
-        {
-            free(compressed);
-            compressed = NULL;
-            output_compression = GTA_NONE;
-        }
-        else
-        {
-            output_compression = header->compression;
-        }
-    }
+    output_compression = GTA_NONE;
     errno = 0;
     r = write_fn(userdata, &output_compression, sizeof(uint8_t), &error);
     if (error || r < sizeof(uint8_t))
@@ -1332,51 +1321,19 @@ gta_write_chunk(const gta_header_t *GTA_RESTRICT header,
         retval = GTA_SYSTEM_ERROR;
         goto exit;
     }
-    if (output_compression == GTA_NONE)
-    {
-        errno = 0;
-        r = write_fn(userdata, chunk, chunk_size, &error);
-        if (error || r < chunk_size)
-        {
-            if (errno == 0)
-            {
-                errno = EIO;
-            }
-            retval = GTA_SYSTEM_ERROR;
-            goto exit;
-        }
-    }
-    else
+    errno = 0;
+    r = write_fn(userdata, chunk, chunk_size, &error);
+    if (error || r < chunk_size)
     {
-        size_compressed = compressed_size;
-        errno = 0;
-        r = write_fn(userdata, &size_compressed, sizeof(uint64_t), &error);
-        if (error || r < sizeof(uint64_t))
-        {
-            if (errno == 0)
-            {
-                errno = EIO;
-            }
-            retval = GTA_SYSTEM_ERROR;
-            goto exit;
-        }
-        errno = 0;
-        r = write_fn(userdata, compressed, compressed_size, &error);
-        if (error || r < compressed_size)
+        if (errno == 0)
         {
-            if (errno == 0)
-            {
-                errno = EIO;
-            }
-            retval = GTA_SYSTEM_ERROR;
-            goto exit;
+            errno = EIO;
         }
-        free(compressed);
-        compressed = NULL;
+        retval = GTA_SYSTEM_ERROR;
+        goto exit;
     }
 
 exit:
-    free(compressed);
     return retval;
 }
 
@@ -2657,12 +2614,7 @@ gta_write_header(const gta_header_t *GTA_RESTRICT header, gta_write_t write_fn,
 #if WORDS_BIGENDIAN
     firstblock[4] |= 0x01;
 #endif
-    if (header->compression != GTA_NONE)
-    {
-        // This is only here so that libgta versions <= 0.9.2 can read files created by this libgta version.
-        firstblock[4] |= 0x02;
-    }
-    firstblock[5] = header->compression;
+    firstblock[5] = GTA_NONE;
     errno = 0;
     r = write_fn(userdata, firstblock, 6, &output_error);
     if (output_error || r < 6)
@@ -3182,13 +3134,18 @@ gta_get_data_size(const gta_header_t *GTA_RESTRICT header)
 gta_compression_t
 gta_get_compression(const gta_header_t *GTA_RESTRICT header)
 {
+    /* We do not support compression anymore. This function will be removed in
+     * a future version. */
     return header->compression;
 }
 
 void
 gta_set_compression(gta_header_t *GTA_RESTRICT header, gta_compression_t compression)
 {
-    header->compression = compression;
+    /* We do not support compression anymore. This function does nothing and
+     * will be removed in a future version. */
+    (void)header;
+    (void)compression;
 }
 
 
@@ -3318,6 +3275,7 @@ gta_read_data(const gta_header_t *GTA_RESTRICT header, void *GTA_RESTRICT data,
     // We know that the data size fits into size_t, because the caller already allocated a buffer for all the data.
     if (gta_get_compression(header) != GTA_NONE)
     {
+#if WITH_COMPRESSION
         char *data_ptr = data;
         size_t remaining_size = gta_get_data_size(header);
         void *chunk;
@@ -3352,6 +3310,9 @@ gta_read_data(const gta_header_t *GTA_RESTRICT header, void *GTA_RESTRICT data,
             remaining_size -= chunk_size;
             data_ptr += chunk_size;
         }
+#else
+        return GTA_UNSUPPORTED_DATA;
+#endif
     }
     else
     {
@@ -3396,6 +3357,7 @@ gta_skip_data(const gta_header_t *GTA_RESTRICT header, gta_read_t read_fn, gta_s
 
     if (gta_get_compression(header) != GTA_NONE)
     {
+#if WITH_COMPRESSION
         uintmax_t s = gta_get_data_size(header);
         size_t chunk_size;
         while (s > 0)
@@ -3424,6 +3386,9 @@ gta_skip_data(const gta_header_t *GTA_RESTRICT header, gta_read_t read_fn, gta_s
         {
             return GTA_INVALID_DATA;
         }
+#else
+        return GTA_UNSUPPORTED_DATA;
+#endif
     }
     else
     {
@@ -3470,49 +3435,18 @@ gta_result_t
 gta_write_data(const gta_header_t *GTA_RESTRICT header, const void *GTA_RESTRICT data, gta_write_t write_fn, intptr_t userdata)
 {
     // We know that the data size fits into size_t, because the caller already allocated a buffer for all the data.
-    if (gta_get_compression(header) != GTA_NONE)
-    {
-        const char *chunk_ptr = data;
-        size_t remaining_size = gta_get_data_size(header);
-        size_t chunk_size;
-        gta_result_t retval;
-
-        for (;;)
-        {
-            chunk_size = gta_max_chunk_size;
-            if (chunk_size > remaining_size)
-            {
-                chunk_size = remaining_size;
-            }
-            retval = gta_write_chunk(header, chunk_ptr, chunk_size, write_fn, userdata);
-            if (retval != GTA_OK)
-            {
-                return retval;
-            }
-            if (chunk_size == 0)
-            {
-                break;
-            }
-            chunk_ptr += chunk_size;
-            remaining_size -= chunk_size;
-        }
-        return GTA_OK;
-    }
-    else
+    int output_error = false;
+    errno = 0;
+    size_t r = write_fn(userdata, data, gta_get_data_size(header), &output_error);
+    if (output_error || r < gta_get_data_size(header))
     {
-        int output_error = false;
-        errno = 0;
-        size_t r = write_fn(userdata, data, gta_get_data_size(header), &output_error);
-        if (output_error || r < gta_get_data_size(header))
+        if (errno == 0)
         {
-            if (errno == 0)
-            {
-                errno = EIO;
-            }
-            return GTA_SYSTEM_ERROR;
+            errno = EIO;
         }
-        return GTA_OK;
+        return GTA_SYSTEM_ERROR;
     }
+    return GTA_OK;
 }
 
 gta_result_t
@@ -3561,6 +3495,7 @@ gta_copy_data(const gta_header_t *GTA_RESTRICT read_header, gta_read_t read_fn,
 
     if (gta_get_compression(read_header) != GTA_NONE)
     {
+#if WITH_COMPRESSION
         void *chunk = NULL;
         size_t chunk_size = 0;
         do
@@ -3576,23 +3511,16 @@ gta_copy_data(const gta_header_t *GTA_RESTRICT read_header, gta_read_t read_fn,
                 free(chunk);
                 return GTA_INVALID_DATA;
             }
-            if (gta_get_compression(write_header) != GTA_NONE)
-            {
-                retval = gta_write_chunk(write_header, chunk, chunk_size, write_fn, write_userdata);
-            }
-            else
+            int error = false;
+            errno = 0;
+            size_t r = write_fn(write_userdata, chunk, chunk_size, &error);
+            if (error || r < chunk_size)
             {
-                int error = false;
-                errno = 0;
-                size_t r = write_fn(write_userdata, chunk, chunk_size, &error);
-                if (error || r < chunk_size)
+                if (errno == 0)
                 {
-                    if (errno == 0)
-                    {
-                        errno = EIO;
-                    }
-                    retval = GTA_SYSTEM_ERROR;
+                    errno = EIO;
                 }
+                retval = GTA_SYSTEM_ERROR;
             }
             free(chunk);
             if (retval != GTA_OK)
@@ -3606,6 +3534,9 @@ gta_copy_data(const gta_header_t *GTA_RESTRICT read_header, gta_read_t read_fn,
         {
             return GTA_UNEXPECTED_EOF;
         }
+#else
+        return GTA_UNSUPPORTED_DATA;
+#endif
     }
     else
     {
@@ -3618,16 +3549,6 @@ gta_copy_data(const gta_header_t *GTA_RESTRICT read_header, gta_read_t read_fn,
         {
             return GTA_SYSTEM_ERROR;
         }
-        if (gta_get_compression(write_header) != GTA_NONE)
-        {
-            chunk_size = (size < gta_max_chunk_size ? size : gta_max_chunk_size);
-            chunk = malloc(chunk_size);
-            if (!chunk)
-            {
-                free(buffer);
-                return GTA_SYSTEM_ERROR;
-            }
-        }
         while (size > 0)
         {
             int error = false;
@@ -3645,54 +3566,22 @@ gta_copy_data(const gta_header_t *GTA_RESTRICT read_header, gta_read_t read_fn,
                 free(chunk);
                 return GTA_UNEXPECTED_EOF;
             }
-            if (gta_get_compression(write_header) != GTA_NONE)
+            error = false;
+            errno = 0;
+            r = write_fn(write_userdata, buffer, x, &error);
+            if (error || r < x)
             {
-                retval = gta_write_blob_to_chunk(write_header, write_fn, write_userdata,
-                        chunk, chunk_size, &chunk_index, buffer, x);
-                if (retval != GTA_OK)
+                if (errno == 0)
                 {
-                    free(buffer);
-                    free(chunk);
-                    return retval;
-                }
-            }
-            else
-            {
-                int error = false;
-                errno = 0;
-                r = write_fn(write_userdata, buffer, x, &error);
-                if (error || r < x)
-                {
-                    if (errno == 0)
-                    {
-                        errno = EIO;
-                    }
-                    free(buffer);
-                    free(chunk);
-                    return GTA_SYSTEM_ERROR;
+                    errno = EIO;
                 }
+                free(buffer);
+                free(chunk);
+                return GTA_SYSTEM_ERROR;
             }
             size -= x;
         }
         free(buffer);
-        if (gta_get_compression(write_header) != GTA_NONE)
-        {
-            if (chunk_index > 0)
-            {
-                retval = gta_write_chunk(write_header, chunk, chunk_index, write_fn, write_userdata);
-                if (retval != GTA_OK)
-                {
-                    free(chunk);
-                    return retval;
-                }
-            }
-            free(chunk);
-            retval = gta_write_chunk(write_header, NULL, 0, write_fn, write_userdata);
-            if (retval != GTA_OK)
-            {
-                return retval;
-            }
-        }
     }
     return GTA_OK;
 }
@@ -3819,10 +3708,15 @@ gta_read_elements(const gta_header_t *GTA_RESTRICT header, gta_io_state_t *GTA_R
         {
             if (gta_get_compression(header) != GTA_NONE)
             {
+#if WITH_COMPRESSION
                 free(io_state->chunk);
                 io_state->chunk = NULL;
                 gta_result_t retval = gta_read_chunk(header, &(io_state->chunk),
                         &(io_state->chunk_size), read_fn, userdata);
+#else
+                gta_result_t retval = GTA_UNSUPPORTED_DATA;
+
+#endif
                 if (retval != GTA_OK)
                 {
                     goto exit;
@@ -3880,6 +3774,7 @@ gta_read_elements(const gta_header_t *GTA_RESTRICT header, gta_io_state_t *GTA_R
     {
         if (gta_get_compression(header) != GTA_NONE)
         {
+#if WITH_COMPRESSION
             if (io_state->chunk_index != io_state->chunk_size)
             {
                 retval = GTA_INVALID_DATA;
@@ -3899,6 +3794,10 @@ gta_read_elements(const gta_header_t *GTA_RESTRICT header, gta_io_state_t *GTA_R
                 retval = GTA_INVALID_DATA;
                 goto exit;
             }
+#else
+            retval = GTA_UNSUPPORTED_DATA;
+            goto exit;
+#endif
         }
         else
         {
@@ -3975,59 +3874,34 @@ gta_write_elements(const gta_header_t *GTA_RESTRICT header, gta_io_state_t *GTA_
     {
         if (io_state->chunk_index == io_state->chunk_size)
         {
-            if (gta_get_compression(header) != GTA_NONE)
+            if (!io_state->chunk)
             {
-                if (io_state->counter > 0)
+                size_t chunk_size = gta_max_chunk_size;
+                if (gta_get_data_size(header) < chunk_size)
                 {
-                    retval = gta_write_chunk(header, io_state->chunk,
-                            io_state->chunk_index, write_fn, userdata);
-                    if (retval != GTA_OK)
-                    {
-                        goto exit;
-                    }
+                    chunk_size = gta_get_data_size(header);
                 }
-                free(io_state->chunk);
-                uintmax_t remaining_data = gta_get_data_size(header)
-                    - io_state->counter * gta_get_element_size(header) - i;
-                io_state->chunk_size = (remaining_data < gta_max_chunk_size) ? remaining_data : gta_max_chunk_size;
-                io_state->chunk = malloc(io_state->chunk_size);
+                io_state->chunk = malloc(chunk_size);
                 if (!io_state->chunk)
                 {
                     retval = GTA_SYSTEM_ERROR;
                     goto exit;
                 }
+                io_state->chunk_size = chunk_size;
             }
-            else
+            if (io_state->chunk_index > 0)
             {
-                if (!io_state->chunk)
-                {
-                    size_t chunk_size = gta_max_chunk_size;
-                    if (gta_get_data_size(header) < chunk_size)
-                    {
-                        chunk_size = gta_get_data_size(header);
-                    }
-                    io_state->chunk = malloc(chunk_size);
-                    if (!io_state->chunk)
-                    {
-                        retval = GTA_SYSTEM_ERROR;
-                        goto exit;
-                    }
-                    io_state->chunk_size = chunk_size;
-                }
-                if (io_state->chunk_index > 0)
+                int error = false;
+                errno = 0;
+                size_t r = write_fn(userdata, io_state->chunk, io_state->chunk_size, &error);
+                if (error || r < io_state->chunk_size)
                 {
-                    int error = false;
-                    errno = 0;
-                    size_t r = write_fn(userdata, io_state->chunk, io_state->chunk_size, &error);
-                    if (error || r < io_state->chunk_size)
+                    if (errno == 0)
                     {
-                        if (errno == 0)
-                        {
-                            errno = EIO;
-                        }
-                        retval = GTA_SYSTEM_ERROR;
-                        goto exit;
+                        errno = EIO;
                     }
+                    retval = GTA_SYSTEM_ERROR;
+                    goto exit;
                 }
             }
             io_state->chunk_index = 0;
@@ -4044,47 +3918,25 @@ gta_write_elements(const gta_header_t *GTA_RESTRICT header, gta_io_state_t *GTA_
     io_state->counter += n;
     if (io_state->counter == gta_get_elements(header))
     {
-        if (gta_get_compression(header) != GTA_NONE)
+        // flush
+        if (io_state->chunk_index > 0)
         {
-            // flush chunk and write empty chunk
-            if (io_state->chunk_index > 0)
+            int error = false;
+            errno = 0;
+            size_t r = write_fn(userdata, io_state->chunk, io_state->chunk_index, &error);
+            if (error || r < io_state->chunk_index)
             {
-                retval = gta_write_chunk(header, io_state->chunk, io_state->chunk_index, write_fn, userdata);
-                if (retval != GTA_OK)
+                if (errno == 0)
                 {
-                    goto exit;
+                    errno = EIO;
                 }
-            }
-            free(io_state->chunk);
-            io_state->chunk = NULL;
-            retval = gta_write_chunk(header, NULL, 0, write_fn, userdata);
-            if (retval != GTA_OK)
-            {
+                retval = GTA_SYSTEM_ERROR;
                 goto exit;
             }
         }
-        else
-        {
-            // flush
-            if (io_state->chunk_index > 0)
-            {
-                int error = false;
-                errno = 0;
-                size_t r = write_fn(userdata, io_state->chunk, io_state->chunk_index, &error);
-                if (error || r < io_state->chunk_index)
-                {
-                    if (errno == 0)
-                    {
-                        errno = EIO;
-                    }
-                    retval = GTA_SYSTEM_ERROR;
-                    goto exit;
-                }
-            }
-            // free the chunk; it will not be needed anymore
-            free(io_state->chunk);
-            io_state->chunk = NULL;
-        }
+        // free the chunk; it will not be needed anymore
+        free(io_state->chunk);
+        io_state->chunk = NULL;
     }
 exit:
     if (retval != GTA_OK)
index 61b5411..08a14ce 100644 (file)
@@ -4,7 +4,7 @@
  * This file is part of libgta, a library that implements the Generic Tagged
  * Array (GTA) file format.
  *
- * Copyright (C) 2010, 2011, 2012, 2014
+ * Copyright (C) 2010, 2011, 2012, 2014, 2019
  * Martin Lambers <marlam@marlam.de>
  *
  * Libgta is free software: you can redistribute it and/or modify it under the
@@ -39,7 +39,6 @@
  * - GTAs can store any kind of data in multidimensional arrays\n
  * - GTAs can optionally use simple tags to store rich metadata\n
  * - GTAs are streamable, which allows direct reading from and writing to pipes, network sockets, and other non-seekable media\n
- * - GTAs can use ZLIB, BZIP2, or XZ compression, allowing a tradeoff between compression/decompression speed and compression ratio\n
  * - Uncompressed GTA files allow easy out-of-core data access for very large arrays
  *
  * See the <a href="https://marlam.de/gta/specification.pdf">GTA file format specification</a> for details.
@@ -237,8 +236,7 @@ typedef enum
     /**<
      * \brief   Invalid data
      *
-     * Some data was invalid. For example, an input file is not in GTA format,
-     * or decompression of the data failed.
+     * Some data was invalid. For example, an input file is not in GTA format.
      */
     GTA_SYSTEM_ERROR = 5
     /**<
@@ -291,13 +289,7 @@ typedef enum
 /**
  * \brief       GTA compression algorithms
  *
- * Compression algorithms used to compress the array.\n
- * Only uncompressed files are suitable for out-of-core data access; compressed
- * files must be decompressed first.\n
- * \a GTA_ZLIB compression is fast and achieves a moderate compression ratio.
- * \a GTA_BZIP2 compression is moderately fast and achieves a good compression ratio.
- * \a GTA_XZ compression is slow for compression, moderately fast for decompression,
- * and achieves good or very good compression rates.
+ * These are deprecated. Do not use them anymore, they will be removed in a future version.
  */
 typedef enum
 {
@@ -401,7 +393,7 @@ GTA_ATTR_NOTHROW;
  *
  * Creates a new GTA header and initializes it.
  * The GTA will initially be empty (zero element components, zero dimensions)
- * and contain no tags. The compression method will be \a GTA_NONE.
+ * and contain no tags.
  */
 extern GTA_EXPORT gta_result_t
 gta_create_header(gta_header_t *GTA_RESTRICT *GTA_RESTRICT header)
@@ -661,10 +653,10 @@ GTA_ATTR_NONNULL_ALL GTA_ATTR_PURE GTA_ATTR_NOTHROW;
  * \param header        The header.
  * \return              The compression type.
  *
- * Gets the compression type for the header and data.\n
- * See \a gta_compression_t for more information on compression types.\n
- * Compressed data is always stored in chunks, while uncompressed
- * data is never stored in chunks.
+ * Gets the compression type for the header and data. Compression
+ * is deprecated so the return value should always be GTA_NONE, unless
+ * you read legacy files.
+ * This function will be removed in a future version.
  */
 extern GTA_EXPORT gta_compression_t
 gta_get_compression(const gta_header_t *GTA_RESTRICT header)
@@ -675,8 +667,9 @@ GTA_ATTR_NONNULL_ALL GTA_ATTR_NOTHROW;
  * \param header        The header.
  * \param compression   The compression type.
  *
- * Sets the compression type for writing the header and data.\n
- * See \a gta_compression_t for more information on compression types.
+ * Sets the compression type for writing the header and data.
+ * Compression is deprecated and this function actually does nothing.
+ * This function will be removed in a future version.
  */
 extern GTA_EXPORT void
 gta_set_compression(gta_header_t *GTA_RESTRICT header, gta_compression_t compression)
@@ -968,7 +961,7 @@ GTA_ATTR_WARN_UNUSED_RESULT GTA_ATTR_NONNULL1(1) GTA_ATTR_NOTHROW;
  * \return              \a GTA_OK or \a GTA_SYSTEM_ERROR.
  *
  * Copies the complete data.
- * The data encoding is altered as necessary (endianness correction, compression).
+ * The data encoding is altered as necessary (endianness correction).
  * Note that the data encoding may change even if \a read_header and \a write_header
  * point to the same header!
  */
@@ -987,7 +980,7 @@ GTA_ATTR_WARN_UNUSED_RESULT GTA_ATTR_NONNULL_ALL;
  * \return              \a GTA_OK or \a GTA_SYSTEM_ERROR.
  *
  * Copies the complete data.
- * The data encoding is altered as necessary (endianness correction, compression).
+ * The data encoding is altered as necessary (endianness correction).
  * Note that the data encoding may change even if \a read_header and \a write_header
  * point to the same header!
  */
@@ -1006,7 +999,7 @@ GTA_ATTR_WARN_UNUSED_RESULT GTA_ATTR_NONNULL_ALL GTA_ATTR_NOTHROW;
  * \return              \a GTA_OK or \a GTA_SYSTEM_ERROR.
  *
  * Copies the complete data.
- * The data encoding is altered as necessary (endianness correction, compression).
+ * The data encoding is altered as necessary (endianness correction).
  * Note that the data encoding may change even if \a read_header and \a write_header
  * point to the same header!
  */
@@ -1123,7 +1116,7 @@ GTA_ATTR_NONNULL1(1) GTA_ATTR_PURE GTA_ATTR_NOTHROW;
  * These functions are intended to be used for filtering a complete array on a per-element basis.
  * They read or write a given number of elements, and it is expected that they are used
  * repeatedly until all elements of an array have been read or written.
- * Theses function work for all GTAs, with or without compression, an the input and output streams
+ * Theses function work for all GTAs, an the input and output streams
  * do not need to be seekable.
  *
  * Element-based input/output needs a state structure. This structure must be allocated with
@@ -1273,8 +1266,7 @@ GTA_ATTR_WARN_UNUSED_RESULT GTA_ATTR_NONNULL_ALL;
  *
  * \name Read and Write Array Blocks
  *
- * These functions can only be used if the data is not compression (see \a gta_get_compression())
- * and the input/output is seekable.\n
+ * These functions can only be used if the input/output is seekable.\n
  * They are suitable for applications that do not want to store the complete array data in
  * memory.\n
  * A block is given by the lowest and highest element coordinates in each dimension.
index a1b14d4..35296ff 100644 (file)
@@ -4,7 +4,7 @@
  * This file is part of libgta, a library that implements the Generic Tagged
  * Array (GTA) file format.
  *
- * Copyright (C) 2010, 2011, 2012
+ * Copyright (C) 2010, 2011, 2012, 2019
  * Martin Lambers <marlam@marlam.de>
  *
  * Libgta is free software: you can redistribute it and/or modify it under the
@@ -88,8 +88,7 @@ namespace gta
         /**<
          * \brief   Invalid data
          *
-         * Some data was invalid. For example, an input file is not in GTA format,
-         * or decompression of the data failed.
+         * Some data was invalid. For example, an input file is not in GTA format.
          */
         system_error = GTA_SYSTEM_ERROR
         /**<
@@ -142,15 +141,7 @@ namespace gta
     /**
      * \brief GTA compression methods
      *
-     * This is equivalent to \a gta_compression_t from the C interface.
-     *
-     * Compression algorithms used to compress the array.\n
-     * Only uncompressed files are suitable for out-of-core data access; compressed
-     * files must be decompressed first.\n
-     * \a gta::zlib compression is fast and achieves a moderate compression ratio.
-     * \a gta::bzip2 compression is moderately fast and achieves a good compression ratio.
-     * \a gta::xz compression is slow for compression, moderately fast for decompression,
-     * and achieves good or very good compression rates.
+     * These are deprecated. Do not use them anymore, they will be removed in a future version.
      */
     enum compression
     {
@@ -1077,9 +1068,9 @@ namespace gta
          * \return              The compression type.
          *
          * Gets the compression type for the header and data.\n
-         * See \a gta_compression_t for more information on compression types.\n
-         * Compressed data is always stored in chunks, while uncompressed
-         * data is never stored in chunks.
+         * Compression is deprecated so the return value should always be gta::none,
+         * unless you read legacy files.
+         * This function will be removed in a future version.
          */
         gta::compression compression() const
         {
@@ -1090,8 +1081,9 @@ namespace gta
          * \brief               Set the compression.
          * \param compression   The compression type.
          *
-         * Sets the compression type for writing the header and data.\n
-         * See \a gta_compression_t for more information on compression types.
+         * Sets the compression type for writing the header and data.
+         * Compression is deprecated and this function actually does nothing.
+         * This function will be removed in a future version.
          */
         void set_compression(gta::compression compression)
         {
@@ -1753,7 +1745,7 @@ namespace gta
          * These functions are intended to be used for filtering a complete array on a per-element basis.
          * They read or write a given number of elements, and it is expected that they are used
          * repeatedly until all elements of an array have been read or written.
-         * Theses function work for all GTAs, with or without compression, an the input and output streams
+         * Theses function work for all GTAs, and the input and output streams
          * do not need to be seekable.
          *
          * Element-based input/output needs a state object gta::io_state. The same state object must be
@@ -1913,8 +1905,7 @@ namespace gta
         /**
          * \name Read and Write Array Blocks
          *
-         * These functions can only be used if the data is not compressed (see \a header::compression())
-         * and the input/output is seekable.\n
+         * These functions can only be used if the input/output is seekable.\n
          * They are suitable for applications that do not want to store the complete array data in
          * memory.\n
          * A block is given by the lowest and highest element coordinates in each dimension.
index 2ac7e69..27ef7a0 100644 (file)
@@ -7,24 +7,26 @@
 
 check_PROGRAMS = \
        basic           \
-       compression     \
        taglists        \
        filedescriptors \
-       endianness      \
        blocks          \
        elements        \
        fuzztest-create \
        fuzztest-check
+if WITH_COMPRESSION
+check_PROGRAMS += endianness
+endif
 
 TESTS = \
        basic           \
-       compression     \
        taglists        \
        filedescriptors \
-       endianness      \
        blocks          \
        elements        \
        fuzztest.sh
+if WITH_COMPRESSION
+TESTS += endianness
+endif
 
 EXTRA_DIST = little-endian.gta big-endian.gta fuzztest.sh
 
index 604f7a5..ca9c8f4 100644 (file)
@@ -145,7 +145,6 @@ int main(void)
     check(gta_get_element_size(header) == 0);
     check(gta_get_dimensions(header) == 0);
     check(gta_get_data_size(header) == 0);
-    check(gta_get_compression(header) == GTA_NONE);
     r = gta_read_data_from_stream(header, data, f);
     check(r == GTA_OK);
     r = gta_read_header_from_stream(header, f);
diff --git a/libgta/tests/compression.c b/libgta/tests/compression.c
deleted file mode 100644 (file)
index 94b8bec..0000000
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
- * compression.c
- *
- * This file is part of libgta, a library that implements the Generic Tagged
- * Array (GTA) file format.
- *
- * Copyright (C) 2010, 2011
- * Martin Lambers <marlam@marlam.de>
- *
- * Libgta is free software: you can redistribute it and/or modify it under the
- * terms of the GNU Lesser General Public License as published by the Free
- * Software Foundation, either version 2.1 of the License, or (at your option)
- * any later version.
- *
- * Libgta is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Libgta. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <gta/gta.h>
-
-#define check(condition) \
-    /* fprintf(stderr, "%s:%d: %s: Checking '%s'.\n", __FILE__, __LINE__, __PRETTY_FUNCTION__, #condition); */ \
-    if (!(condition)) \
-    { \
-        fprintf(stderr, "%s:%d: %s: Check '%s' failed.\n", \
-                __FILE__, __LINE__, __PRETTY_FUNCTION__, #condition); \
-        exit(1); \
-    }
-
-int main(void)
-{
-    gta_header_t *header;
-    gta_result_t r;
-    FILE *f;
-
-    r = gta_create_header(&header);
-    check(r == GTA_OK);
-
-    /* Define an array */
-    gta_type_t types[] = {
-        GTA_FLOAT32,
-        GTA_FLOAT32,
-        GTA_FLOAT32,
-    };
-    r = gta_set_components(header, 3, types, NULL);
-    check(r == GTA_OK);
-    uintmax_t dims[] = { 100, 100 };
-    r = gta_set_dimensions(header, 2, dims);
-    check(r == GTA_OK);
-
-    /* Check data size */
-    uintmax_t element_size = gta_get_element_size(header);
-    check(element_size == 4 + 4 + 4);
-    uintmax_t elements = gta_get_elements(header);
-    check(elements = 100 * 100);
-    uintmax_t data_size = gta_get_data_size(header);
-    check(data_size == element_size * elements);
-
-    /* Create the array data */
-    uint8_t *data = malloc(data_size);
-    check(data);
-    for (uintmax_t x = 0; x < 100; x++)
-    {
-        for (uintmax_t y = 0; y < 100; y++)
-        {
-            uintmax_t indices[2] = { x, y };
-            float *element = gta_get_element(header, data, indices);
-            element[0] = (float)(y * 100 + x) + 0.0f;
-            element[1] = (float)(y * 100 + x) + 0.3f;
-            element[2] = (float)(y * 100 + x) + 0.6f;
-        }
-    }
-
-    /* Write the array to a file */
-    f = fopen("test-compression.tmp", "w");
-    check(f);
-    // Compression GTA_NONE
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB
-    gta_set_compression(header, GTA_ZLIB);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB1
-    gta_set_compression(header, GTA_ZLIB1);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB2
-    gta_set_compression(header, GTA_ZLIB2);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB3
-    gta_set_compression(header, GTA_ZLIB3);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB4
-    gta_set_compression(header, GTA_ZLIB4);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB5
-    gta_set_compression(header, GTA_ZLIB5);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB6
-    gta_set_compression(header, GTA_ZLIB6);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB7
-    gta_set_compression(header, GTA_ZLIB7);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB8
-    gta_set_compression(header, GTA_ZLIB8);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_ZLIB9
-    gta_set_compression(header, GTA_ZLIB9);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_BZIP2
-    gta_set_compression(header, GTA_BZIP2);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    // Compression GTA_XZ
-    gta_set_compression(header, GTA_XZ);
-    r = gta_write_header_to_stream(header, f);
-    check(r == GTA_OK);
-    r = gta_write_data_to_stream(header, data, f);
-    check(r == GTA_OK);
-    fclose(f);
-
-    /* Reread the same file */
-    f = fopen("test-compression.tmp", "r");
-    check(f);
-    uint8_t *data2 = malloc(data_size);
-    check(data2);
-    // Compression GTA_NONE
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_NONE);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB1
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB1);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB2
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB2);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB3
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB3);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB4
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB4);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB5
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB5);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB6
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB6);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB7
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB7);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB8
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB8);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_ZLIB9
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_ZLIB9);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_BZIP2
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_BZIP2);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-    // Compression GTA_XZ
-    r = gta_read_header_from_stream(header, f);
-    check(r == GTA_OK);
-    check(gta_get_components(header) == 3);
-    check(gta_get_element_size(header) == element_size);
-    check(gta_get_dimensions(header) == 2);
-    check(gta_get_elements(header) == elements);
-    check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_XZ);
-    r = gta_read_data_from_stream(header, data2, f);
-    check(r == GTA_OK);
-    check(memcmp(data, data2, data_size) == 0);
-
-    int c = fgetc(f);
-    check(c == EOF && feof(f));
-
-    fclose(f);
-    remove("test-compression.tmp");
-    free(data);
-    free(data2);
-
-    gta_destroy_header(header);
-
-    return 0;
-}
index 0036704..d4a44e5 100644 (file)
 
 int main(void)
 {
-    FILE *fu, *fc;
-    gta_header_t *hu, *hc;
-    gta_io_state_t *su, *sc;
+    FILE *f;
+    gta_header_t *h;
+    gta_io_state_t *s;
     gta_result_t r;
     uintmax_t dims[] = { 7, 11, 13, 17 };
     uintmax_t index;
 
-    r = gta_create_header(&hu);
-    r = gta_create_header(&hc);
+    r = gta_create_header(&h);
     check(r == GTA_OK);
 
     /* Define an array */
     gta_type_t types[] = { GTA_UINT16 };
-    r = gta_set_components(hu, 1, types, NULL);
+    r = gta_set_components(h, 1, types, NULL);
     check(r == GTA_OK);
-    r = gta_set_components(hc, 1, types, NULL);
+    r = gta_set_dimensions(h, 4, dims);
     check(r == GTA_OK);
-    r = gta_set_dimensions(hu, 4, dims);
-    check(r == GTA_OK);
-    r = gta_set_dimensions(hc, 4, dims);
-    check(r == GTA_OK);
-    gta_set_compression(hc, GTA_ZLIB);
 
-    /* Write the array with and without compression */
-    fu = fopen("test-elements-uncompressed.tmp", "w");
-    check(fu);
-    fc = fopen("test-elements-compressed.tmp", "w");
-    check(fc);
-    r = gta_write_header_to_stream(hu, fu);
-    check(r == GTA_OK);
-    r = gta_write_header_to_stream(hc, fc);
-    check(r == GTA_OK);
-    r = gta_create_io_state(&su);
+    /* Write the array */
+    f = fopen("test-elements.tmp", "w");
+    check(f);
+    r = gta_write_header_to_stream(h, f);
     check(r == GTA_OK);
-    r = gta_create_io_state(&sc);
+    r = gta_create_io_state(&s);
     check(r == GTA_OK);
     index = 0;
-    for (uintmax_t w = 0; w < gta_get_dimension_size(hu, 3); w++)
+    for (uintmax_t w = 0; w < gta_get_dimension_size(h, 3); w++)
     {
-        for (uintmax_t z = 0; z < gta_get_dimension_size(hu, 2); z++)
+        for (uintmax_t z = 0; z < gta_get_dimension_size(h, 2); z++)
         {
-            for (uintmax_t y = 0; y < gta_get_dimension_size(hu, 1); y++)
+            for (uintmax_t y = 0; y < gta_get_dimension_size(h, 1); y++)
             {
-                for (uintmax_t x = 0; x < gta_get_dimension_size(hu, 0); x++)
+                for (uintmax_t x = 0; x < gta_get_dimension_size(h, 0); x++)
                 {
                     uintmax_t indices[4] = { x, y, z, w };
-                    uintmax_t test_index = gta_indices_to_linear_index(hu, indices);
+                    uintmax_t test_index = gta_indices_to_linear_index(h, indices);
                     check(test_index == index);
                     uintmax_t test_indices[4] = { -1, -1, -1, -1 };
-                    gta_linear_index_to_indices(hu, index, test_indices);
+                    gta_linear_index_to_indices(h, index, test_indices);
                     check(test_indices[0] == indices[0]);
                     check(test_indices[1] == indices[1]);
                     check(test_indices[2] == indices[2]);
                     check(test_indices[3] == indices[3]);
                     uint16_t i = index;
-                    r = gta_write_elements_to_stream(hu, su, 1, &i, fu);
-                    check(r == GTA_OK);
-                    r = gta_write_elements_to_stream(hc, sc, 1, &i, fc);
+                    r = gta_write_elements_to_stream(h, s, 1, &i, f);
                     check(r == GTA_OK);
                     index++;
                 }
             }
         }
     }
-    gta_destroy_io_state(su);
-    gta_destroy_io_state(sc);
-    fclose(fu);
-    fclose(fc);
+    gta_destroy_io_state(s);
+    fclose(f);
 
     /* Open the files, read and check the arrays */
-    fu = fopen("test-elements-uncompressed.tmp", "r");
-    check(fu);
-    fc = fopen("test-elements-compressed.tmp", "r");
-    check(fc);
-    r = gta_read_header_from_stream(hu, fu);
-    check(r == GTA_OK);
-    r = gta_read_header_from_stream(hc, fc);
+    f = fopen("test-elements.tmp", "r");
+    check(f);
+    r = gta_read_header_from_stream(h, f);
     check(r == GTA_OK);
-    r = gta_create_io_state(&su);
-    check(r == GTA_OK);
-    r = gta_create_io_state(&sc);
+    r = gta_create_io_state(&s);
     check(r == GTA_OK);
     index = 0;
-    for (uintmax_t w = 0; w < gta_get_dimension_size(hu, 3); w++)
+    for (uintmax_t w = 0; w < gta_get_dimension_size(h, 3); w++)
     {
-        for (uintmax_t z = 0; z < gta_get_dimension_size(hu, 2); z++)
+        for (uintmax_t z = 0; z < gta_get_dimension_size(h, 2); z++)
         {
-            for (uintmax_t y = 0; y < gta_get_dimension_size(hu, 1); y++)
+            for (uintmax_t y = 0; y < gta_get_dimension_size(h, 1); y++)
             {
-                for (uintmax_t x = 0; x < gta_get_dimension_size(hu, 0); x++)
+                for (uintmax_t x = 0; x < gta_get_dimension_size(h, 0); x++)
                 {
-                    uint16_t iu, ic;
-                    r = gta_read_elements_from_stream(hu, su, 1, &iu, fu);
-                    check(r == GTA_OK);
-                    r = gta_read_elements_from_stream(hc, sc, 1, &ic, fc);
+                    uint16_t i;
+                    r = gta_read_elements_from_stream(h, s, 1, &i, f);
                     check(r == GTA_OK);
-                    check(iu == index);
-                    check(iu == ic);
+                    check(i == index);
                     index++;
                 }
             }
         }
     }
-    gta_destroy_io_state(su);
-    gta_destroy_io_state(sc);
-    fclose(fu);
-    fclose(fc);
+    gta_destroy_io_state(s);
+    fclose(f);
 
-    gta_destroy_header(hu);
-    gta_destroy_header(hc);
-    remove("test-elements-uncompressed.tmp");
-    remove("test-elements-compressed.tmp");
+    gta_destroy_header(h);
+    remove("test-elements.tmp");
     return 0;
 }
index b7039f6..5fca2f5 100644 (file)
@@ -366,7 +366,6 @@ int main(void)
     /* Write the array to a file */
     f = fopen("test-endianness.tmp", "w");
     check(f);
-    gta_set_compression(header, GTA_BZIP2);
     r = gta_write_header_to_stream(header, f);
     check(r == GTA_OK);
     r = gta_write_data_to_stream(header, data, f);
@@ -375,7 +374,7 @@ int main(void)
 
     /* Read the two endianness test files.
      * They were generated with the above code on little and big endian systems
-     * and their contant must be identical to the content we just generated. */
+     * and their content must be identical to the content we just generated. */
     f = fopen(le_test_file, "r");
     check(f);
     r = gta_read_header_from_stream(le_header, f);
index 387ff4f..3c95cd3 100644 (file)
@@ -87,10 +87,6 @@ int main(int argc, char *argv[])
     check(r == 0);
     r = gta_copy_data_stream(iheader, f, oheader, nullf);
     check(r == GTA_OK);
-    if (gta_get_compression(oheader) == GTA_NONE)
-        gta_set_compression(oheader, GTA_ZLIB);
-    else
-        gta_set_compression(oheader, GTA_NONE);
     r = fseeko(f, data_offset, SEEK_SET);
     check(r == 0);
     r = gta_copy_data_stream(iheader, f, oheader, nullf);
@@ -119,10 +115,6 @@ int main(int argc, char *argv[])
         check(r == GTA_OK);
         r = gta_create_io_state(&ostate);
         check(r == GTA_OK);
-        if (gta_get_compression(oheader) == GTA_NONE)
-            gta_set_compression(oheader, GTA_ZLIB);
-        else
-            gta_set_compression(oheader, GTA_NONE);
         for (uintmax_t i = 0; i < gta_get_elements(iheader); i++) {
             r = gta_read_elements_from_stream(iheader, istate, 1, data, f);
             check(r == GTA_OK);
@@ -165,10 +157,6 @@ int main(int argc, char *argv[])
         r = gta_copy_data_stream(iheader, f, oheader, nullf);
         r = fseeko(f, data_offset, SEEK_SET);
         check(r == 0);
-        if (gta_get_compression(oheader) == GTA_NONE)
-            gta_set_compression(oheader, GTA_ZLIB);
-        else
-            gta_set_compression(oheader, GTA_NONE);
         r = gta_copy_data_stream(iheader, f, oheader, nullf);
         free(data);
         /* Read/write the data element-wise */
@@ -199,10 +187,6 @@ int main(int argc, char *argv[])
             check(r == GTA_OK);
             r = gta_create_io_state(&ostate);
             check(r == GTA_OK);
-            if (gta_get_compression(oheader) == GTA_NONE)
-                gta_set_compression(oheader, GTA_ZLIB);
-            else
-                gta_set_compression(oheader, GTA_NONE);
             for (uintmax_t i = 0; i < gta_get_elements(iheader); i++) {
                 r = gta_read_elements_from_stream(iheader, istate, 1, data, f);
                 if (r != GTA_OK)
index bbeafaa..a3a0d60 100644 (file)
@@ -52,10 +52,6 @@ int main(int argc, char *argv[])
         GTA_FLOAT32, GTA_FLOAT64, GTA_FLOAT128,
         GTA_CFLOAT32, GTA_CFLOAT64, GTA_CFLOAT128
     };
-    const gta_compression_t zlib_variants[10] = {
-        GTA_ZLIB, GTA_ZLIB1, GTA_ZLIB2, GTA_ZLIB3, GTA_ZLIB4,
-        GTA_ZLIB5, GTA_ZLIB6, GTA_ZLIB7, GTA_ZLIB8, GTA_ZLIB9
-    };
     const int tag_variants = 3;
     const char *tag_names[] = { "TAG0", "X", "_?_" };
     const char *tag_values[] = { "", "42", "(*)" };
@@ -76,21 +72,6 @@ int main(int argc, char *argv[])
     /* Create a header */
     r = gta_create_header(&header);
     check(r == GTA_OK);
-    if (rand_in_range(0, 1)) {
-        gta_set_compression(header, GTA_NONE);
-    } else {
-        switch (rand_in_range(0, 2)) {
-        case 0:
-            gta_set_compression(header, GTA_BZIP2);
-            break;
-        case 1:
-            gta_set_compression(header, GTA_XZ);
-            break;
-        default:
-            gta_set_compression(header, zlib_variants[rand_in_range(0, 9)]);
-            break;
-        }
-    }
 
     /* Set global tags */
     int global_tags = rand_in_range(0, 3);
@@ -178,14 +159,7 @@ int main(int argc, char *argv[])
     gta_destroy_header(header);
 
     /* Now corrupt the second file */
-    int max_corrupt_offset;
-    if (gta_get_compression(header) == GTA_NONE) {
-        /* Not much point in corrupting the uncompressed data since we do not check it */
-        max_corrupt_offset = header_size - 1;
-    } else {
-        /* In this case, we can hit chunk lists and/or compressed data */
-        max_corrupt_offset = total_size - 1;
-    }
+    int max_corrupt_offset = header_size - 1;
     f = fopen(argv[3], "r+");
     check(f);
     int corruptions = rand_in_range(1, 4);
index a22f2ca..db7b746 100644 (file)
@@ -158,7 +158,6 @@ int main(void)
     check(gta_get_element_size(header) == element_size);
     check(gta_get_dimensions(header) == 4);
     check(gta_get_data_size(header) == data_size);
-    check(gta_get_compression(header) == GTA_NONE);
     r = gta_read_data_from_stream(header, data2, f);
     check(r == GTA_OK);
     check(memcmp(data, data2, data_size) == 0);