zopfli draft

cmake/modules/FindZOPFLI.cmake

@@ -0,0 +1,59 @@
+# Find the ZOPFLI includes and library.
+#
+# This module defines
+# ZOPFLI_INCLUDE_DIR, where to locate ZOPFLI header files
+# ZOPFLI_LIBRARIES, the libraries to link against to use ZOPFLI
+# ZOPFLI_FOUND.  If false, you cannot build anything that requires ZOPFLI.
+
+if(ZOPFLI_CONFIG_EXECUTABLE)
+  set(ZOPFLI_FIND_QUIETLY 1)
+endif()
+set(ZOPFLI_FOUND 0)
+
+if(NOT ZOPFLI_DIR)
+  set(ZOPFLI_DIR $ENV{ZOPFLI_DIR})
+endif()
+
+find_path(ZOPFLI_INCLUDE_DIR zopfli.h PATHS
+  ${ZOPFLI_DIR}/include
+  /usr/include
+  /usr/local/include
+  /opt/zopfli/include
+  NO_DEFAULT_PATH
+  NO_SYSTEM_ENVIRONMENT_PATH
+  DOC "Specify the directory containing zopfli.h"
+)
+
+find_library(ZOPFLI_LIBRARY NAMES zopfli PATHS
+  ${ZOPFLI_DIR}/lib
+  /usr/local/zopfli/lib
+  /usr/local/lib
+  /usr/lib/zopfli
+  /usr/local/lib/zopfli
+  /usr/zopfli/lib /usr/lib
+  /usr/zopfli /usr/local/zopfli
+  /opt/zopfli /opt/zopfli/lib
+  NO_DEFAULT_PATH
+  NO_SYSTEM_ENVIRONMENT_PATH
+  DOC "Specify the zopfli library here."
+)
+
+if(ZOPFLI_INCLUDE_DIR)
+  message(STATUS "Found ZOPFLI includes at ${ZOPFLI_INCLUDE_DIR}")
+else()
+  message(STATUS "ZOPFLI includes not found")
+endif()
+
+if(ZOPFLI_LIBRARY)
+  message(STATUS "Found ZOPFLI library at ${ZOPFLI_LIBRARY}")
+else()
+  message(STATUS "ZOPFLI library not found")
+endif()
+
+
+if(ZOPFLI_INCLUDE_DIR AND ZOPFLI_LIBRARY)
+  set(ZOPFLI_FOUND 1)
+endif()
+
+set(ZOPFLI_LIBRARIES ${ZOPFLI_LIBRARY})
+mark_as_advanced(ZOPFLI_FOUND ZOPFLI_LIBRARY ZOPFLI_INCLUDE_DIR)

cmake/modules/RootBuildOptions.cmake

@@ -76,6 +76,7 @@ ROOT_BUILD_OPTION(builtin_pcre OFF "Build included libpcre, or use system libpcr
 ROOT_BUILD_OPTION(builtin_zlib OFF "Build included libz, or use system libz")
 ROOT_BUILD_OPTION(builtin_lzma OFF "Build included liblzma, or use system liblzma")
 ROOT_BUILD_OPTION(lzo OFF "LZO support, requires liblzo2")
+ROOT_BUILD_OPTION(zopfli OFF "ZOPFLI support, requires libzopfli")
 ROOT_BUILD_OPTION(lz4 OFF "LZ4 support, (either included lz4 or system lz4)")
 ROOT_BUILD_OPTION(builtin_lz4 OFF "Build included lz4, or use system liblz4")
 ROOT_BUILD_OPTION(builtin_davix OFF "Build the Davix library internally (downloading tarfile from the Web)")

cmake/modules/RootConfiguration.cmake

@@ -439,6 +439,11 @@ if(lzma)
 else()
   set(haslzmacompression undef)
 endif()
+if(zopfli)
+  set(haszopflicompression define)
+else()
+  set(haszopflicompression undef)
+endif()
 if(lz4)
   set(haslz4compression define)
 else()

cmake/modules/SearchInstalledSoftware.cmake

@@ -561,6 +561,20 @@ if(lzo)
   endif()
 endif()
 
+#---Check for ZOPFLI------------------------------------------------------------------
+if(zopfli)
+  message(STATUS "Looking for ZOPFLI")
+  find_package(ZOPFLI)
+  if(NOT ZOPFLI_FOUND)
+    if(fail-on-missing)
+      message(FATAL_ERROR "zopfli not found but required (zopfli option enabled)")
+    else()
+      message(STATUS "zopfli not found. Switching off zopfli option")
+      set(zopfli OFF CACHE BOOL "" FORCE)
+    endif()
+  endif()
+endif()
+
 #---Check for OpenSSL------------------------------------------------------------------
 if(ssl OR builtin_openssl)
   if(builtin_openssl)

core/CMakeLists.txt

@@ -36,6 +36,11 @@ if(lzo)
   set(lzo_objects $<TARGET_OBJECTS:Lzo>)
   set(lzo_library ${LZO_LIBRARIES})
 endif()
+if(zopfli)
+  add_subdirectory(zopfli)
+  set(zopfli_objects $<TARGET_OBJECTS:Zopfli>)
+  set(zopfli_library ${ZOPFLI_LIBRARIES})
+endif()
 if(lz4)
   add_subdirectory(lz4)
   set(lz4_objects $<TARGET_OBJECTS:Lz4>)
@@ -57,6 +62,7 @@ set(objectlibs $<TARGET_OBJECTS:Base>
                ${macosx_objects}
                ${unix_objects}
                ${lzo_objects}
+               ${zopfli_objects}
                ${lz4_objects}
                ${winnt_objects})
 
@@ -116,7 +122,7 @@ add_subdirectory(utils)
 ROOT_LINKER_LIBRARY(Core
                     $<TARGET_OBJECTS:BaseTROOT>
                     ${objectlibs}
-                    LIBRARIES ${PCRE_LIBRARIES} ${lzo_library} ${lz4_library} ${LZMA_LIBRARIES} ${ZLIB_LIBRARY}
+                    LIBRARIES ${PCRE_LIBRARIES} ${lzo_library} ${zopfli_library} ${lz4_library} ${LZMA_LIBRARIES} ${ZLIB_LIBRARY}
                               ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT} ${corelinklibs} )
 
 if(cling)

core/zip/CMakeLists.txt

@@ -46,6 +46,9 @@ else()
   set(ZLIB_HEADERS ${ZipOldHeaders})
   set(ZLIB_SRCS ${ZipOldSource} ${CMAKE_CURRENT_SOURCE_DIR}/src/Compression.cxx ${CMAKE_CURRENT_SOURCE_DIR}/src/RZip.cxx)
 endif()
+if(zopfli)
+  ROOT_ADD_CXX_FLAG(CMAKE_C_FLAGS -DZOPFLI)
+endif()
 if(lz4)
   ROOT_ADD_CXX_FLAG(CMAKE_C_FLAGS -DLZ4)
 endif()

core/zip/src/Bits.h

@@ -32,7 +32,7 @@ void R__zipLZ4(int cxlevel, int *srcsize, char *src, int *tgtsize, char *tgt, in
 }
 #endif
 #ifdef ZOPFLI
-#include "ZipZOPFLI.h"
+extern void R__zipZOPFLI(int cxlevel, int *srcsize, char *src, int *tgtsize, char *tgt, int *irep) ;
 #else
 void R__zipZOPFLI(int cxlevel, int *srcsize, char *src, int *tgtsize, char *tgt, int *irep) {
   R__error("ROOT built without ZOPFLI support");

core/zopfli/CMakeLists.txt

@@ -0,0 +1,11 @@
+############################################################################
+# CMakeLists.txt file for building ROOT core/zopfli package
+############################################################################
+
+#---Declare ZipZOPFLI sources as part of libCore-------------------------------
+set(sources ${CMAKE_CURRENT_SOURCE_DIR}/src/ZipZOPFLI.c)
+
+include_directories(${ZOPFLI_INCLUDE_DIR})
+
+ROOT_OBJECT_LIBRARY(Zopfli ${sources})
+

core/zopfli/src/ZipZOPFLI.c

@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+
+#include "zopfli/zopfli.h"
+
+#ifndef NULL
+#define NULL 0L
+#endif
+
+typedef char              boolean;
+typedef unsigned char     uch;  /* code assumes unsigned bytes; these type-  */
+typedef unsigned short    ush;  /*  defs replace byte/UWORD/ULONG (which are */
+typedef unsigned long     ulg;  /*  predefined on some systems) & match zip  */
+
+extern void R__error(const char *msg);
+#define HDRSIZE 9
+
+
+int R__ZopfliCompress(ZopfliOptions* zpfopts, ZopfliFormat zpftype,
+        uch* src, size_t srcsize, char* target, size_t* dstsz)
+{
+  uch* compression_target = 0;
+  size_t compression_size = 0;
+  unsigned long adler32;
+  lzo_uint obufs;
+  lzo_uint osz;
+  lzo_uintp obufsz;
+  uch* obufptr;
+
+  obufs = *dstsz;
+  obufsz = &obufs;
+  (target)[0] = 'Z';
+  (target)[1] = 'P';
+  if (ZOPFLI_FORMAT_ZLIB == zpftype) (target)[2] = 'Z';
+  if (ZOPFLI_FORMAT_GZIP == zpftype) (target)[2] = 'G';
+  if (ZOPFLI_FORMAT_DEFLATE == zpftype) (target)[2] = 'D';
+  ZopfliCompress(zpfopts, zpftype, src, srcsize, &compression_target, &compression_size);
+  if (compression_size > srcsize) {
+    free(compression_target);
+    if (*dstsz < srcsize + HDRSIZE + 4) {
+      R__error("could not leave uncompressed");
+      return -1;
+    }
+    memmove(target + HDRSIZE,src,srcsize);
+    target[2]=0;
+    compression_size = srcsize;
+  } else {
+    if (*dstsz < compression_size + HDRSIZE + 4) {
+      /* this is actually caught */
+      R__error("could not compress");
+      free(compression_target);
+      return -1;
+    }
+    memmove(target + HDRSIZE,compression_target,compression_size);
+    free(compression_target);
+  }
+
+  /* does all this make sense? */
+  *dstsz = compression_size + HDRSIZE + 4;
+  *obufsz = compression_size + HDRSIZE + 4;
+  osz = *obufsz - HDRSIZE;
+  (target)[3] = (char)(((osz) >> 0) & 0xff);
+  (target)[4] = (char)(((osz) >> 8) & 0xff);
+  (target)[5] = (char)(((osz) >>16) & 0xff);
+  (target)[6] = (char)(((srcsize) >> 0) & 0xff);
+  (target)[7] = (char)(((srcsize) >> 8) & 0xff);
+  (target)[8] = (char)(((srcsize) >>16) & 0xff);
+  /* calculate checksum */
+  adler32 = lzo_adler32(
+      lzo_adler32(0, NULL,0), (target) + HDRSIZE, osz - 4);
+  obufptr = target;
+  obufptr += *obufsz - 4;
+  obufptr[0] = (char) (adler32 & 0xff);
+  obufptr[1] = (char) ((adler32 >> 8) & 0xff);
+  obufptr[2] = (char) ((adler32 >> 16) & 0xff);
+  obufptr[3] = (char) ((adler32 >> 24) & 0xff);
+
+  return 0;
+
+}
+
+void R__zipZOPFLI(int cxlevel, int *srcsize, char *src, int *tgtsize, char *tgt, int *irep)
+{
+  size_t dstsz = *tgtsize;
+  ZopfliFormat zpftype;
+  ZopfliOptions zpfopts;
+  ZopfliInitOptions(&zpfopts);
+  zpfopts.numiterations = cxlevel;
+  zpftype = ZOPFLI_FORMAT_ZLIB; /* also possible GZIP or DEFLATE */
+  if (R__ZopfliCompress( &zpfopts, zpftype, (uch*) src, *srcsize, tgt, &dstsz)) {
+    *irep = 0;
+  } else {
+    *irep = dstsz;
+  }
+  *tgtsize = dstsz;
+}
+
+