rough draft for lzo

cmake/modules/RootBuildOptions.cmake

@@ -75,6 +75,7 @@ ROOT_BUILD_OPTION(builtin_openssl OFF "Build OpenSSL internally, or use system O
 ROOT_BUILD_OPTION(builtin_pcre OFF "Build included libpcre, or use system libpcre")
 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(builtin_davix OFF "Build the Davix library internally (downloading tarfile from the Web)")
 ROOT_BUILD_OPTION(builtin_gsl OFF "Build the GSL library internally (downloading tarfile from the Web)")
 ROOT_BUILD_OPTION(builtin_cfitsio OFF "Build the FITSIO library internally (downloading tarfile from the Web)")

cmake/modules/RootConfiguration.cmake

@@ -439,6 +439,11 @@ if(lzma)
 else()
   set(haslzmacompression undef)
 endif()
+if(lzo)
+  set(haslzocompression define)
+else()
+  set(haslzocompression undef)
+endif()
 if(cocoa)
   set(hascocoa define)
 else()

cmake/modules/SearchInstalledSoftware.cmake

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

core/CMakeLists.txt

@@ -31,6 +31,13 @@ if(cocoa)
 endif()
 add_subdirectory(zip)
 add_subdirectory(lzma)
+if(lzo)
+  add_subdirectory(lzo)
+  set(lzo_objects $<TARGET_OBJECTS:Lzo>)
+  set(lzo_library ${LZO_LIBRARY})
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DLZO")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DLZO")
+endif
 add_subdirectory(base)
 
 set(objectlibs $<TARGET_OBJECTS:Base>
@@ -43,6 +50,7 @@ set(objectlibs $<TARGET_OBJECTS:Base>
                $<TARGET_OBJECTS:TextInput>
                ${macosx_objects}
                ${unix_objects}
+               ${lzo_objects}
                ${winnt_objects})
 
 #---Generation of RGitCommit.h-----------------------------------------------------------
@@ -101,7 +109,7 @@ add_subdirectory(utils)
 ROOT_LINKER_LIBRARY(Core
                     $<TARGET_OBJECTS:BaseTROOT>
                     ${objectlibs}
-                    LIBRARIES ${PCRE_LIBRARIES} ${LZMA_LIBRARIES} ${ZLIB_LIBRARY}
+                    LIBRARIES ${PCRE_LIBRARIES} ${lzo_library} ${LZMA_LIBRARIES} ${ZLIB_LIBRARY}
                               ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT} ${corelinklibs} )
 
 if(cling)

core/utils/CMakeLists.txt

@@ -32,7 +32,8 @@ ROOT_EXECUTABLE(rootcling src/LinkdefReader.cxx src/DictSelectionReader.cxx
                           ${macosx_objects}
                           ${unix_objects}
                           ${winnt_objects}
-                          LIBRARIES ${PCRE_LIBRARIES} ${LZMA_LIBRARIES} ${ZLIB_LIBRARY}
+                          ${lzo_objects}
+                          LIBRARIES ${PCRE_LIBRARIES} ${lzo_library} ${LZMA_LIBRARIES} ${ZLIB_LIBRARY}
                                     ${CLING_LIBRARIES} ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT}
                                     ${corelinklibs})
 

core/zip/inc/Compression.h

@@ -26,6 +26,8 @@ namespace ROOT {
    // and memory when compressing.  LZMA memory usage is particularly
    // high for compression levels 8 and 9.
    //
+   // TODO: add comment for lzo,lz4,zopfli,brotli
+   //
    // The current algorithms support level 1 to 9. The higher
    // the level the greater the compression and more CPU time
    // and memory resources used during compression. Level 0
@@ -34,6 +36,10 @@ namespace ROOT {
                                 kZLIB,
                                 kLZMA,
                                 kOldCompressionAlgo,
+                                kLZO,
+                                kLZ4,
+                                kZOPFLI,
+                                kBROTLI,
                                 // if adding new algorithm types,
                                 // keep this enum value last
                                 kUndefinedCompressionAlgorithm

core/zip/src/Bits.h

@@ -15,6 +15,14 @@
 #include "zlib.h"
 #include "RConfigure.h"
 #include "ZipLZMA.h"
+#ifdef LZO
+#include "ZipLZO.h"
+#else
+void R__zipLZO(int cxlevel, int *srcsize, char *src, int *tgtsize, char *tgt, int *irep) {
+  R__error("ROOT built without LZO support");
+  return ;
+}
+#endif
 
 #include <stdio.h>
 #include <assert.h>
@@ -287,11 +295,17 @@ struct bits_internal_state {
    and when R__zipMultipleAlgorithm is called with its last argument set to 0.
    R__ZipMode = 1 : ZLIB compression algorithm is used (default)
    R__ZipMode = 2 : LZMA compression algorithm is used
+   R__ZipMode = 4 : LZO compression algorithm is used
+   R__ZipMode = 5 : LZ4 compression algorithm is used
+   R__ZipMode = 6 : ZOPFLI compression algorithm is used
+   R__ZipMode = 7 : BROTLI compression algorithm is used
    R__ZipMode = 0 or 3 : a very old compression algorithm is used
    (the very old algorithm is supported for backward compatibility)
    The LZMA algorithm requires the external XZ package be installed when linking
    is done. LZMA typically has significantly higher compression factors, but takes
    more CPU time and memory resources while compressing.
+
+TODO: add comments for lzo,lz4,zopfli,brotli
 */
 int R__ZipMode = 1;
 
@@ -583,6 +597,22 @@ void R__zipMultipleAlgorithm(int cxlevel, int *srcsize, char *src, int *tgtsize,
   if (compressionAlgorithm == 2) {
     R__zipLZMA(cxlevel, srcsize, src, tgtsize, tgt, irep);
     return;
+  } else if (compressionAlgorithm == 4) {
+    // The LZO compression algorithm
+    R__zipLZO(cxlevel, srcsize, src, tgtsize, tgt, irep);
+    return;
+  } else if (compressionAlgorithm == 5) {
+    // The LZ4 compression algorithm
+    R__zipLZ4(cxlevel, srcsize, src, tgtsize, tgt, irep);
+    return;
+  } else if (compressionAlgorithm == 5) {
+    // The ZOPFLI compression algorithm
+    R__zipZOPFLI(cxlevel, srcsize, src, tgtsize, tgt, irep);
+    return;
+  } else if (compressionAlgorithm == 6) {
+    // The BROTLI compression algorithm
+    R__zipBROTLI(cxlevel, srcsize, src, tgtsize, tgt, irep);
+    return;
   }
 
   // The very old algorithm for backward compatibility

core/zip/src/ZInflate.c

@@ -20,6 +20,18 @@ static const int qflag = 0;
 #include "zlib.h"
 #include "RConfigure.h"
 #include "ZipLZMA.h"
+#ifdef LZO
+#include "ZipLZO.h"
+#else
+void R__unzipLZO(int *srcsize, unsigned char *src, int *tgtsize, unsigned char *tgt, int *irep) {
+  fprintf(stderr,
+      "R__unzipLZO: ROOT built without LZO\n");
+  return;
+}
+#endif
+#include "ZipLZ4.h"
+#include "ZipZOPFLI.h"
+#include "ZipBROTLI.h"
 
 
 /* inflate.c -- put in the public domain by Mark Adler
@@ -1130,10 +1142,33 @@ int R__unzip_header(int *srcsize, uch *src, int *tgtsize)
   /*   C H E C K   H E A D E R   */
   if (!(src[0] == 'Z' && src[1] == 'L' && src[2] == Z_DEFLATED) &&
       !(src[0] == 'C' && src[1] == 'S' && src[2] == Z_DEFLATED) &&
-      !(src[0] == 'X' && src[1] == 'Z' && src[2] == 0)) {
+      !(src[0] == 'X' && src[1] == 'Z' && src[2] == 0) &&
+      !(src[0] == 'L' && src[1] == 'Z') &&
+      !(src[0] == 'L' && src[1] == '4') &&
+      !(src[0] == 'B' && src[1] == 'R') &&
+      !(src[0] == 'Z' && src[1] == 'P')) {
     fprintf(stderr, "Error R__unzip_header: error in header\n");
     return 1;
   }
+#ifndef LZO
+  if (src[0] == 'L' && src[1] == 'Z') {
+    fprintf(stderr, "Error R__unzip_header: ROOT built without LZO\n");
+    return 2;
+  }
+#endif
+#ifndef LZ4
+  if (src[0] == 'L' && src[1] == '4') {
+    fprintf(stderr, "Error R__unzip_header: ROOT built without LZ4\n");
+    return 2;
+  }
+#endif
+/// ZOPFLI is decompressed with zlib, no check needed
+#ifndef BROTLI
+  if (src[0] == 'B' && src[1] == 'R') {
+    fprintf(stderr, "Error R__unzip_header: ROOT built without BROTLI\n");
+    return 2;
+  }
+#endif
 
   *srcsize = HDRSIZE + ((long)src[3] | ((long)src[4] << 8) | ((long)src[5] << 16));
   *tgtsize = (long)src[6] | ((long)src[7] << 8) | ((long)src[8] << 16);
@@ -1159,10 +1194,33 @@ void R__unzip(int *srcsize, uch *src, int *tgtsize, uch *tgt, int *irep)
   /*   C H E C K   H E A D E R   */
   if (!(src[0] == 'Z' && src[1] == 'L' && src[2] == Z_DEFLATED) &&
       !(src[0] == 'C' && src[1] == 'S' && src[2] == Z_DEFLATED) &&
-      !(src[0] == 'X' && src[1] == 'Z' && src[2] == 0)) {
-    fprintf(stderr,"Error R__unzip: error in header\n");
-    return;
+      !(src[0] == 'X' && src[1] == 'Z' && src[2] == 0) &&
+      !(src[0] == 'L' && src[1] == 'Z') &&
+      !(src[0] == 'L' && src[1] == '4') &&
+      !(src[0] == 'B' && src[1] == 'R') &&
+      !(src[0] == 'Z' && src[1] == 'P')) {
+    fprintf(stderr, "Error R__unzip: error in header\n");
+    return 1;
+  }
+#ifndef LZO
+  if (src[0] == 'L' && src[1] == 'Z') {
+    fprintf(stderr, "Error R__unzip: ROOT built without LZO\n");
+    return 2;
   }
+#endif
+#ifndef LZ4
+  if (src[0] == 'L' && src[1] == '4') {
+    fprintf(stderr, "Error R__unzip: ROOT built without LZ4\n");
+    return 2;
+  }
+#endif
+/// ZOPFLI is decompressed with zlib, no check needed
+#ifndef BROTLI
+  if (src[0] == 'B' && src[1] == 'R') {
+    fprintf(stderr, "Error R__unzip: ROOT built without BROTLI\n");
+    return 2;
+  }
+#endif
 
   ibufptr = src + HDRSIZE;
   ibufcnt = (long)src[3] | ((long)src[4] << 8) | ((long)src[5] << 16);