Fixes for most compiler warnings using GCC 7.3.0 and mingw-w64.

src/CMakeLists.txt

@@ -1,9 +1,14 @@
 cmake_minimum_required(VERSION 2.8.12)
 project(flif)
 
+include(GNUInstallDirs)
+include(FindPkgConfig)
 find_package(PNG REQUIRED)
 include_directories(${PNG_INCLUDE_DIRS})
+option(BUILD_SHARED_LIBS "Build shared FLIF encoder/decoder libraries" ON)
+option(BUILD_STATIC_LIBS "Build static FLIF encoder/decoder libraries" ON)
 
+set(SOVERSION 0)
 # find SDL2
 
 find_package(PkgConfig QUIET)
@@ -37,7 +42,9 @@ include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(SDL2
                                   REQUIRED_VARS SDL2_INCLUDE_DIR SDL2_LIBRARY SDL2MAIN_LIBRARY)
 
-# /find SDL2
+if(PKG_CONFIG_FOUND)
+pkg_check_modules(GDK gdk-pixbuf-2.0 )
+endif(PKG_CONFIG_FOUND)
 set(FLIF_SRC_DIR ${CMAKE_CURRENT_LIST_DIR})
 
 set(COMMON_SOURCES
@@ -59,15 +66,65 @@ set(COMMON_SOURCES
     ${FLIF_SRC_DIR}/../extern/lodepng.cpp
 )
 
+set(FLIF_DEC_FILES
+  ${FLIF_SRC_DIR}/library/flif_dec.h 
+  ${FLIF_SRC_DIR}/library/flif-interface-private_dec.hpp
+  ${FLIF_SRC_DIR}/library/flif-interface_dec.cpp)
+
+set(FLIF_DEC_HEADERS
+    ${FLIF_SRC_DIR}/library/flif_common.h
+    ${FLIF_SRC_DIR}/library/flif_dec.h
+)
+set(FLIF_ENC_FILES
+  ${FLIF_SRC_DIR}/flif-enc.cpp
+  ${FLIF_SRC_DIR}/library/flif-interface.cpp
+)
+set(FLIF_ENC_HEADERS
+    ${FLIF_SRC_DIR}/library/flif.h
+    ${FLIF_SRC_DIR}/library/flif_common.h
+    ${FLIF_SRC_DIR}/library/flif_dec.h
+    ${FLIF_SRC_DIR}/library/flif_enc.h
+)
+
 if(WIN32)
     set(STATIC_LINKED_LIBS ${ZLIB_LIBRARY})
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wextra")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra")
+    if(WIN32)
+#This is neeeded to prevent warnings such as:
+#mingw The ABI for passing parameters with 16-byte alignment has changed in GCC 4.6
+#if you compile for i686.
+#but the downside is that the compiled binaries might not work with some old CPU's.
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx")
+    endif(WIN32)
     set(CMAKE_CXX_FLAGS_DEBUG "-ggdb3")
-    set(CMAKE_CXX_FLAGS_RELEASE "-O3")
-endif()
+    set(CMAKE_C_FLAGS_DEBUG "-ggdb3")
+    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -ftree-vectorize")
+    set(CMAKE_C_FLAGS_RELEASE "-O3 -ftree-vectorize")
+else()
+# Clang specific things
+# from: https://stackoverflow.com/questions/10046114/in-cmake-how-can-i-test-if-the-compiler-is-clang
+    if (CMAKE_CXX_COMPILER_ID MATCHES "[cC][lL][aA][nN][gG]") #Case insensitive match
+       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wextra")
+       set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra")
+       if(WIN32)
+#This is neeeded to prevent warnings such as:
+#mingw The ABI for passing parameters with 16-byte alignment has changed in GCC 4.6
+#if you compile for i686.
+#but the downside is that the compiled binaries might not work with some old CPU's.
+          set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
+          set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx")
+      endif(WIN32)
+      set(CMAKE_CXX_FLAGS_DEBUG "-ggdb3")
+      set(CMAKE_C_FLAGS_DEBUG "-ggdb3")
+      set(CMAKE_CXX_FLAGS_RELEASE "-O3 -ftree-vectorize")
+      set(CMAKE_C_FLAGS_RELEASE "-O3 -ftree-vectorize")
+    endif(CMAKE_CXX_COMPILER_ID MATCHES "[cC][lL][aA][nN][gG]") #Case insensitive match
+endif(CMAKE_COMPILER_IS_GNUCXX)
 
 if(USE_ASAN)
     message(STATUS "Using ASAN")
@@ -89,49 +146,205 @@ endif()
 add_executable(flif_exe ${COMMON_SOURCES} ${WINDOWS_EXE_SOURCE} ${FLIF_SRC_DIR}/flif-enc.cpp ${FLIF_SRC_DIR}/flif.cpp)
 target_link_libraries(flif_exe ${PNG_LIBRARY} ${STATIC_LINKED_LIBS})
 set_target_properties(flif_exe PROPERTIES OUTPUT_NAME flif)
+add_executable(dflif_exe ${COMMON_SOURCES} ${WINDOWS_EXE_SOURCE} ${FLIF_SRC_DIR}/flif-enc.cpp ${FLIF_SRC_DIR}/flif.cpp)
+target_compile_definitions(dflif_exe PRIVATE DECODER_ONLY)
+target_link_libraries(dflif_exe ${PNG_LIBRARY} ${STATIC_LINKED_LIBS})
+set_target_properties(dflif_exe PROPERTIES OUTPUT_NAME dflif)
 
 if(WIN32)
     target_include_directories(flif_exe PRIVATE ${FLIF_SRC_DIR}/../build/MSVC/getopt)
     target_compile_definitions(flif_exe PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS} STATIC_GETOPT ) # prevents dllexporting symbols for getopt
+    target_include_directories(dflif_exe PRIVATE ${FLIF_SRC_DIR}/../build/MSVC/getopt)
+    target_compile_definitions(dflif_exe PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS} STATIC_GETOPT ) # prevents dllexporting symbols for getopt
 endif()
 
 # library
+if(BUILD_SHARED_LIBS)
+    add_library(flif_lib SHARED ${COMMON_SOURCES} ${FLIF_ENC_FILES})
+    add_library(flif_lib_dec SHARED ${COMMON_SOURCES} ${FLIF_DEC_FILES} ${FLIF_DEC_HEADERS})
 
-add_library(flif_lib SHARED ${COMMON_SOURCES} ${FLIF_SRC_DIR}/flif-enc.cpp ${FLIF_SRC_DIR}/library/flif-interface.cpp)
-add_library(flif_lib_dec SHARED ${COMMON_SOURCES} ${FLIF_SRC_DIR}/library/flif-interface_dec.cpp)
+    target_link_libraries(flif_lib ${PNG_LIBRARY} ${STATIC_LINKED_LIBS})
+    target_link_libraries(flif_lib_dec ${PNG_LIBRARY} ${STATIC_LINKED_LIBS})
 
-target_link_libraries(flif_lib ${PNG_LIBRARY} ${STATIC_LINKED_LIBS})
-target_link_libraries(flif_lib_dec ${PNG_LIBRARY} ${STATIC_LINKED_LIBS})
+    set_target_properties(flif_lib PROPERTIES OUTPUT_NAME flif)
+    set_target_properties(flif_lib_dec PROPERTIES OUTPUT_NAME flif_dec)
+
+    set_target_properties(flif_lib PROPERTIES PUBLIC_HEADER "${FLIF_ENC_HEADERS}" SOVERSION ${SOVERSION})   
+    set_target_properties(flif_lib_dec PROPERTIES PUBLIC_HEADER "${FLIF_DEC_HEADERS}" SOVERSION ${SOVERSION})
 
-set_target_properties(flif_lib PROPERTIES OUTPUT_NAME flif)
-set_target_properties(flif_lib_dec PROPERTIES OUTPUT_NAME flif_dec)
+    target_compile_definitions(flif_lib PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS} FLIF_BUILD_DLL )
+    target_compile_definitions(flif_lib_dec PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS} FLIF_BUILD_DLL DECODER_ONLY )
 
-target_compile_definitions(flif_lib PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS} FLIF_BUILD_DLL )
-target_compile_definitions(flif_lib_dec PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS} FLIF_BUILD_DLL DECODER_ONLY )
+    target_include_directories(flif_lib PRIVATE ${FLIF_SRC_DIR}/../extern)
+    target_include_directories(flif_lib_dec PRIVATE ${FLIF_SRC_DIR}/../extern)
+
+    target_link_libraries(flif_exe flif_lib)
+    target_link_libraries(dflif_exe flif_lib_dec)
+    install(TARGETS flif_lib flif_lib_dec
+      RUNTIME DESTINATION bin
+      LIBRARY DESTINATION lib
+      ARCHIVE DESTINATION lib
+      PUBLIC_HEADER DESTINATION include)
+endif(BUILD_SHARED_LIBS)
 
 target_include_directories(flif_exe PRIVATE ${FLIF_SRC_DIR}/../extern)
-target_include_directories(flif_lib PRIVATE ${FLIF_SRC_DIR}/../extern)
-target_include_directories(flif_lib_dec PRIVATE ${FLIF_SRC_DIR}/../extern)
+target_include_directories(dflif_exe PRIVATE ${FLIF_SRC_DIR}/../extern)
+install(TARGETS flif_exe dflif_exe
+    RUNTIME DESTINATION bin)
+install(FILES ${FLIF_SRC_DIR}/../tools/gif2flif 
+   PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_READ DESTINATION bin)
+install(FILES ${FLIF_SRC_DIR}/../tools/apng2flif 
+   PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_READ DESTINATION bin)
+install(FILES ${FLIF_SRC_DIR}/../doc/flif.1
+   DESTINATION ${CMAKE_INSTALL_FULL_MANDIR}/man1)
+
+
+if(BUILD_STATIC_LIBS)
+    add_library(flif_lib_static STATIC ${COMMON_SOURCES} ${FLIF_ENC_FILES})
+    add_library(flif_lib_dec_static STATIC ${COMMON_SOURCES} ${FLIF_DEC_FILES})
+
+    target_link_libraries(flif_lib_static ${PNG_LIBRARY} ${STATIC_LINKED_LIBS})
+    target_link_libraries(flif_lib_dec_static ${PNG_LIBRARY} ${STATIC_LINKED_LIBS})
+
+    set_target_properties(flif_lib_static PROPERTIES OUTPUT_NAME flif)
+    set_target_properties(flif_lib_dec_static PROPERTIES OUTPUT_NAME flif_dec)
+
+    set_target_properties(flif_lib_static PROPERTIES PUBLIC_HEADER "${FLIF_ENC_HEADERS}" SOVERSION ${SOVERSION})   
+    set_target_properties(flif_lib_dec_static PROPERTIES PUBLIC_HEADER "${FLIF_DEC_HEADERS}" SOVERSION ${SOVERSION})
+
+    target_compile_definitions(flif_lib_static PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS})
+    target_compile_definitions(flif_lib_dec_static PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS} DECODER_ONLY )
+
+    target_include_directories(flif_lib_static PRIVATE ${FLIF_SRC_DIR}/../extern)
+    target_include_directories(flif_lib_dec_static PRIVATE ${FLIF_SRC_DIR}/../extern)
+
+    install(TARGETS flif_lib_static flif_lib_dec_static
+      RUNTIME DESTINATION bin
+      LIBRARY DESTINATION lib
+      ARCHIVE DESTINATION lib
+      PUBLIC_HEADER DESTINATION include)
+
+    if (NOT(BUILD_SHARED_LIBS))
+       target_link_libraries(flif_exe flif_lib_static)
+       target_link_libraries(dflif_exe flif_lib_dec_static)
+    endif(NOT(BUILD_SHARED_LIBS))
+endif(BUILD_STATIC_LIBS)
+
+# gdk-pixbuf loader, enabling FLIF-viewing in pixbuf applications like Eye of Gnome
+if(GDK_FOUND AND (BUILD_SHARED_LIBS OR BUILD_STATIC_LIBS))
+## The loader is LGPLed so there's no reason to use libflif_dec here
+## -Werror=implicit-function-declaration is useful here to check for preprocessor dependency errors
+#libpixbufloader-flif$(LIBEXT): libflif$(LIBEXT) flif-pixbuf-loader.c
+#	$(CC) -shared $(CFLAGS) -Ilibrary/ -fPIC -Wall -Werror=implicit-function-declaration $(shell pkg-config --cflags gdk-pixbuf-2.0) -o libpixbufloader-flif$(LIBEXT) flif-pixbuf-loader.c $(LDFLAGS) $(shell pkg-config --libs gdk-pixbuf-2.0) -L. -lflif
+    add_library(pixbufloader-flif SHARED flif-pixbuf-loader.c)
+    target_include_directories(pixbufloader-flif PRIVATE ${FLIF_SRC_DIR}/library ${GDK_INCLUDE_DIRS})
+    target_compile_options(pixbufloader-flif PRIVATE ${GDK_CFLAGS})
+    target_compile_definitions(pixbufloader-flif PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS})
+    target_link_libraries(pixbufloader-flif ${GDK_LIBRARIES})
+    set_target_properties(pixbufloader-flif PROPERTIES OUTPUT_NAME pixbufloader-flif)
+
+    add_library(pixbufloader-flif-static STATIC flif-pixbuf-loader.c)
+    target_include_directories(pixbufloader-flif-static PRIVATE ${FLIF_SRC_DIR}/library ${GDK_INCLUDE_DIRS})
+    target_compile_options(pixbufloader-flif-static PRIVATE ${GDK_CFLAGS})
+    target_compile_definitions(pixbufloader-flif-static PRIVATE ${DEFINITIONS_FOR_ALL_TARGETS})
+    target_link_libraries(pixbufloader-flif-static ${GDK_LIBRARIES})
+    set_target_properties(pixbufloader-flif-static PROPERTIES OUTPUT_NAME pixbufloader-flif)
+    if (BUILD_SHARED_LIBS)
+       target_link_libraries(pixbufloader-flif flif_lib)
+       target_link_libraries(pixbufloader-flif-static flif_lib) 
+    else()
+       target_link_libraries(pixbufloader-flif flif_lib_static)
+       target_link_libraries(pixbufloader-flif-static flif_lib_static)
+    endif(BUILD_SHARED_LIBS)
+#We have to be sure that the "-dont-define-prefix", otherwise, on mingw-w64, a complete path
+#is given with pkg-config and that's not desirable for some packaging systems.
+    execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=gdk_pixbuf_moduledir --dont-define-prefix gdk-pixbuf-2.0
+       OUTPUT_VARIABLE GDK_MODULES_DIR ERROR_VARIABLE GDK_RES_ERROR RESULT_VARIABLE RES_VAR OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if (("${RES_VAR}" STREQUAL "") OR ("${RES_VAR}" STREQUAL "0"))
+           message(STATUS "gdk-pixbuf-2.0 module dir ${GDK_MODULES_DIR}")      
+    else()
+           message(FATAL_ERROR "Error: ${RES_VAR}")
+    endif(("${RES_VAR}" STREQUAL "") OR ("${RES_VAR}" STREQUAL "0"))
+    if ("${GDK_RES_ERROR}" STREQUAL "")
+    install(TARGETS pixbufloader-flif pixbufloader-flif-static 
+      RUNTIME DESTINATION ${GDK_MODULES_DIR}
+      LIBRARY DESTINATION ${GDK_MODULES_DIR}
+      ARCHIVE DESTINATION ${GDK_MODULES_DIR}) 
+    else()
+      message(FATAL_ERROR "Error: ${GDK_RES_ERROR}")
+    endif("${GDK_RES_ERROR}" STREQUAL "")
+#You would want to do this on a user's system.
+#
+#    gdk-pixbuf-query-loaders --update-cache
+#
+# We don't do that here because I see this CMakeLists.txt file for software
+#packagers.
+endif(GDK_FOUND AND (BUILD_SHARED_LIBS OR BUILD_STATIC_LIBS))
+
+# mime-info
+find_program(SHARED_MIME_PROG "update-mime-database")
+if (SHARED_MIME_PROG)
+    install(FILES ${FLIF_SRC_DIR}/flif-mime.xml
+      DESTINATION ${CMAKE_INSTALL_FULL_DATAROOTDIR}/mime/packages)
+#you would want to do something like:
+#
+#    execute_process(COMMAND #{SHARED_MIME_PROG} ${CMAKE_INSTALL_PREFIX}/share/mime    )
+#
+#but that type of thing should be done on the user's sytem, not on a build system
+#It does require the "shared-mime-info" package
+endif(SHARED_MIME_PROG)
+
+# Magic data file
+#
+# For deployment, you want to do  something like this on the end-user's system
+#
+#if ! grep -q FLIF /etc/magic; then cat ${CMAKE_INSTALL_FULL_DATAROOTDIR}/doc/flif.magic >> /etc/magic; fi
+#
+install(FILES ${FLIF_SRC_DIR}/../doc/flif.magic
+   DESTINATION ${CMAKE_INSTALL_FULL_DATAROOTDIR}/FLIF)
 
 # viewflif
 
-if(${SDL2_FOUND})
-    add_executable(viewflif ${FLIF_SRC_DIR}/viewflif.c)
-    set_source_files_properties(${FLIF_SRC_DIR}/viewflif.c PROPERTIES LANGUAGE CXX)
-    target_link_libraries(viewflif flif_lib_dec ${SDL2_LIBRARY} ${SDL2MAIN_LIBRARY})
+if(${SDL2_FOUND} AND ${BUILD_SHARED_LIBS})
+    if(WIN32)
+      add_executable(viewflif WIN32 ${FLIF_SRC_DIR}/viewflif.c)
+    else(WIN32)
+      add_executable(viewflif ${FLIF_SRC_DIR}/viewflif.c)
+    endif(WIN32)
+    if ("${PKG_SDL2_STATIC_LIBRARIES}" STREQUAL "")
+      target_link_libraries(viewflif flif_lib_dec ${SDL2_LIBRARY} ${SDL2MAIN_LIBRARY})
+    else("${PKG_SDL2_STATIC_LIBRARIES}" STREQUAL "")
+      target_link_libraries(viewflif flif_lib_dec ${PKG_SDL2_STATIC_LIBRARIES})
+    endif("${PKG_SDL2_STATIC_LIBRARIES}" STREQUAL "")
     target_include_directories(viewflif PRIVATE ${FLIF_SRC_DIR}/library ${SDL2_INCLUDE_DIR})
     target_compile_definitions(viewflif PRIVATE FLIF_USE_DLL)
-endif()
+    install(TARGETS viewflif
+      RUNTIME DESTINATION bin)
+endif(${SDL2_FOUND} AND ${BUILD_SHARED_LIBS})
 
 # test
 
+if(BUILD_SHARED_LIBS)
 add_executable(libtest ${FLIF_SRC_DIR}/../tools/test.c)
 target_link_libraries(libtest flif_lib)
 target_include_directories(libtest PRIVATE ${FLIF_SRC_DIR}/library)
 target_compile_definitions(libtest PRIVATE FLIF_USE_DLL)
+endif(BUILD_SHARED_LIBS)
+
+if(BUILD_STATIC_LIBS)
+add_executable(libtest_static ${FLIF_SRC_DIR}/../tools/test.c)
+target_link_libraries(libtest_static flif_lib)
+target_include_directories(libtest_static PRIVATE ${FLIF_SRC_DIR}/library)
+endif(BUILD_STATIC_LIBS)
+
+# license stuff
+install(FILES "${FLIF_SRC_DIR}/../LICENSE" "${FLIF_SRC_DIR}/../LICENSE_Apache2" "${FLIF_SRC_DIR}/../LICENSE_GPL" "${FLIF_SRC_DIR}/../LICENSE_LGPL" "${FLIF_SRC_DIR}/../FLIF-CLA-template.txt"
+   DESTINATION "${CMAKE_INSTALL_FULL_DATAROOTDIR}/licenses/FLIF")
 
 enable_testing()
 add_test(NAME libtest COMMAND libtest dummy.flif)
+add_test(NAME libtest_static COMMAND libtest_static dummy.flif)
+
 if(UNIX)
     add_test(NAME roundtrip1 COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../tools/test-roundtrip.sh ${CMAKE_CURRENT_SOURCE_DIR}/../tools/2_webp_ll.png 2_webp_ll.flif decoded_2_webp_ll.png)
     add_test(NAME roundtrip2 COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../tools/test-roundtrip.sh ${CMAKE_CURRENT_SOURCE_DIR}/../tools/kodim01.png kodim01.flif decoded_kodim01.png)

src/config.h

@@ -43,6 +43,18 @@
 #define USE_SIMD 1
 #endif
 
+/**************************/
+/* FIX COMPILER WARNINGS  */
+/**************************/
+
+#ifdef FLIF_UNUSED
+#elif defined(__GNUC__) || defined(__clang__)
+# define FLIF_UNUSED(x) x __attribute__((unused)) 
+#elif defined(__LCLINT__) 
+# define FLIF_UNUSED(x) /*@unused@*/ x 
+#else 
+# define FLIF_UNUSED(x) x 
+#endif
 
 /*************************************************/
 /* OPTIONS TO CHANGE DEFAULT ENCODING PARAMETERS */

src/fileio.hpp

@@ -111,7 +111,7 @@ class BlobReader
         else
             return buf;
     }
-    int fputc(int c) {
+    int fputc(int FLIF_UNUSED(c)) {
       // cannot write on const memory
       return EOS;
     }

src/flif-dec.cpp

@@ -167,7 +167,7 @@ void downsample(const int width, const int height, int target_w, int target_h, I
 
 
 template<typename IO, typename Rac, typename Coder>
-bool flif_decode_scanlines_inner(IO &io, Rac &rac, std::vector<Coder> &coders, Images &images, const ColorRanges *ranges, flif_options &options,
+bool flif_decode_scanlines_inner(IO &io, FLIF_UNUSED(Rac &rac), std::vector<Coder> &coders, Images &images, const ColorRanges *ranges, flif_options &options,
                                  std::vector<Transform<IO>*> &transforms, callback_t callback, void *user_data, Images &partial_images) {
     const int nump = images[0].numPlanes();
     const bool alphazero = images[0].alpha_zero_special;
@@ -609,8 +609,8 @@ struct vertical_plane_decoder: public PlaneVisitor {
 };
 
 template<typename IO, typename Rac, typename Coder, typename alpha_t, typename ranges_t>
-bool flif_decode_FLIF2_inner_horizontal(const int p, IO& io, Rac &rac, std::vector<Coder> &coders, Images &images, const ranges_t *ranges,
-                             const int beginZL, const int endZL, int quality, int scale, const int i, const int z, const int predictor, std::vector<int>& zoomlevels, std::vector<Transform<IO>*> &transforms, const int invisible_predictor) {
+bool flif_decode_FLIF2_inner_horizontal(const int p, IO& io, FLIF_UNUSED(Rac &rac), std::vector<Coder> &coders, Images &images, const ranges_t *ranges,
+                             const int beginZL, const int endZL, FLIF_UNUSED(int quality), int scale, const int i, const int z, const int predictor, std::vector<int>& zoomlevels, std::vector<Transform<IO>*> &transforms, const int invisible_predictor) {
     const int nump = images[0].numPlanes();
     const bool alphazero = images[0].alpha_zero_special;
     const bool FRA = (nump == 5);
@@ -640,8 +640,8 @@ bool flif_decode_FLIF2_inner_horizontal(const int p, IO& io, Rac &rac, std::vect
           return true;
 }
 template<typename IO, typename Rac, typename Coder, typename alpha_t, typename ranges_t>
-bool flif_decode_FLIF2_inner_vertical(const int p, IO& io, Rac &rac, std::vector<Coder> &coders, Images &images, const ranges_t *ranges,
-                             const int beginZL, const int endZL, int quality, int scale, const int i, const int z, const int predictor, std::vector<int>& zoomlevels, std::vector<Transform<IO>*> &transforms, const int invisible_predictor) {
+bool flif_decode_FLIF2_inner_vertical(const int p, IO& io, FLIF_UNUSED(Rac &rac), std::vector<Coder> &coders, Images &images, const ranges_t *ranges,
+                             const int beginZL, const int endZL, FLIF_UNUSED(int quality), int scale, const int i, const int z, const int predictor, std::vector<int>& zoomlevels, std::vector<Transform<IO>*> &transforms, const int invisible_predictor) {
     const int nump = images[0].numPlanes();
     const bool alphazero = images[0].alpha_zero_special;
     const bool FRA = (nump == 5);
@@ -855,7 +855,7 @@ bool flif_decode_FLIF2_pass(IO &io, Rac &rac, Images &images, const ColorRanges
 
 
 
-template<typename IO, typename BitChance, typename Rac> bool flif_decode_tree(IO& io, Rac &rac, const ColorRanges *ranges, std::vector<Tree> &forest, const flifEncoding encoding)
+template<typename IO, typename BitChance, typename Rac> bool flif_decode_tree(FLIF_UNUSED(IO& io), Rac &rac, const ColorRanges *ranges, std::vector<Tree> &forest, const flifEncoding encoding)
 {
     try {
       for (int p = 0; p < ranges->numPlanes(); p++) {