Lets try zlib

Signed-off-by: Darby Johnston <[email protected]>

Author: darbyjohnston

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "src/deps/zlib-ng"]
 	path = src/deps/zlib-ng
 	url = https://github.com/zlib-ng/zlib-ng.git
+[submodule "src/deps/zlib"]
+	path = src/deps/zlib
+	url = https://github.com/madler/zlib.git

CMakeLists.txt

@@ -32,7 +32,7 @@ option(OTIO_INSTALL_PYTHON_MODULES    "Install OTIO pure Python modules/files" O
 option(OTIO_INSTALL_COMMANDLINE_TOOLS "Install the OTIO command line tools" ON)
 option(OTIO_FIND_IMATH                "Find Imath using find_package" OFF)
 option(OTIO_FIND_RAPIDJSON            "Find RapidJSON using find_package" OFF)
-option(OTIO_FIND_MINIZIP_NG           "Find minizip-ng using find_package" OFF)
+option(OTIO_FIND_ZLIB                 "Find zlib using find_package" OFF)
 set(OTIO_PYTHON_INSTALL_DIR "" CACHE STRING "Python installation dir (such as the site-packages dir)")
 
 # Build options
@@ -257,14 +257,14 @@ else()
     message(STATUS "Using src/deps/rapidjson by default")
 endif()
 
-#----- minizip-ng
-if(OTIO_FIND_MINIZIP_NG)
-    find_package(minizip-ng CONFIG REQUIRED)
-    if (minizip-ng_FOUND)
-        message(STATUS "Found minizip-ng at ${minizip-ng_CONFIG}")
+#----- zlib
+if(OTIO_FIND_ZLIB)
+    find_package(zlib CONFIG REQUIRED)
+    if (zlib_FOUND)
+        message(STATUS "Found zlib at ${zlib_CONFIG}")
     endif()
 else()
-    message(STATUS "Using src/deps/minizip-ng by default")
+    message(STATUS "Using src/deps/zlib by default")
 endif()
 
 # set up the internally hosted dependencies

src/deps/CMakeLists.txt

@@ -9,8 +9,8 @@ set(DEPS_SUBMODULES pybind11)
 if(NOT OTIO_FIND_RAPIDJSON)
     set(DEPS_SUBMODULES ${DEPS_SUBMODULES} rapidjson)
 endif()
-if(NOT OTIO_FIND_MINIZIP_NG)
-    set(DEPS_SUBMODULES ${DEPS_SUBMODULES} minizip-ng)
+if(NOT OTIO_FIND_ZLIB)
+    set(DEPS_SUBMODULES ${DEPS_SUBMODULES} zlib)
 endif()
 
 foreach(submodule IN LISTS DEPS_SUBMODULES)
@@ -33,23 +33,17 @@ if(NOT OTIO_FIND_IMATH)
     add_subdirectory(Imath)
 endif()
 
-if(NOT OTIO_FIND_MINIZIP_NG)
+if(NOT OTIO_FIND_ZLIB)
     set(BUILD_SHARED_LIBS OFF)
     set(BUILD_TESTING OFF)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-    set(MZ_COMPAT ON)
-    set(MZ_ZLIB ON)
-    set(MZ_ZLIB_FLAVOR zlib-ng)
-    set(MZ_BZIP2 OFF)
-    set(MZ_LZMA OFF)
-    set(MZ_ZSTD OFF)
-    set(MZ_LIBCOMP OFF)
-    set(MZ_PKCRYPT OFF)
-    set(MZ_WZAES OFF)
-    set(MZ_OPENSSL OFF)
-    set(MZ_LIBBSD OFF)
-    set(MZ_ICONV OFF)
-    set(MZ_FETCH_LIBS OFF)
-    add_subdirectory(zlib-ng)
-    add_subdirectory(minizip-ng)
+    set(ZLIB_BUILD_TESTING OFF)
+    # \bug The zlib shared libraries are only enabled to workaround a bug in
+    # the minizip CMake file. We still link to the static zlib.
+    #set(ZLIB_BUILD_SHARED OFF)
+    set(ZLIB_BUILD_MINIZIP ON)
+    set(MINIZIP_BUILD_SHARED OFF)
+    set(MINIZIP_BUILD_TESTING OFF)
+    set(MINIZIP_ENABLE_BZIP2 OFF)
+    add_subdirectory(zlib)
 endif()

src/deps/zlib

@@ -107,7 +107,7 @@ endif()
 
 target_link_libraries(opentimelineio 
     PUBLIC opentime Imath::Imath
-    PRIVATE MINIZIP::minizip)
+    PRIVATE MINIZIP::minizipstatic ZLIB::ZLIBSTATIC)
 
 set_target_properties(opentimelineio PROPERTIES
     DEBUG_POSTFIX "${OTIO_DEBUG_POSTFIX}"

src/opentimelineio/CMakeLists.txt

@@ -8,11 +8,13 @@
 #include "opentimelineio/timeline.h"
 #include "opentimelineio/urlUtils.h"
 
-#include <mz.h>
+/*#include <mz.h>
 #include <mz_os.h>
 #include <mz_strm.h>
 #include <mz_zip.h>
-#include <mz_zip_rw.h>
+#include <mz_zip_rw.h>*/
+#include <unzip.h>
+#include <zip.h>
 
 #include <fstream>
 #include <sstream>
@@ -36,13 +38,14 @@ class ZipWriter
         std::string const& file_name_in_zip);
 
  private:
-    void* _zip = nullptr;
-    uint32_t _attributes = 0;
+    //void* _zip = nullptr;
+    //uint32_t _attributes = 0;
+     zipFile _zip = nullptr;
 };
 
 ZipWriter::ZipWriter(std::string const& zip_file_name)
 {
-    _zip = mz_zip_writer_create();
+    /*_zip = mz_zip_writer_create();
     if (!_zip)
     {
         std::stringstream ss;
@@ -64,15 +67,23 @@ ZipWriter::ZipWriter(std::string const& zip_file_name)
         std::stringstream ss;
         ss << "Cannot get file attributes: '" << zip_file_name << "'.";
         throw std::runtime_error(ss.str());
+    }*/
+    _zip = zipOpen64(zip_file_name.c_str(), 0);
+    if (!_zip)
+    {
+        std::stringstream ss;
+        ss << "Cannot create ZIP writer: '" << zip_file_name << "'.";
+        throw std::runtime_error(ss.str());
     }
 }
 
 ZipWriter::~ZipWriter()
 {
     if (_zip)
     {
-        mz_zip_writer_close(_zip);
-        mz_zip_writer_delete(&_zip);
+        //mz_zip_writer_close(_zip);
+        //mz_zip_writer_delete(&_zip);
+        zipClose(_zip, nullptr);
     }
 }
 
@@ -81,7 +92,7 @@ ZipWriter::add_compressed(
     std::string const& content,
     std::string const& file_name_in_zip)
 {
-    mz_zip_file file_info;
+    /*mz_zip_file file_info;
     memset(&file_info, 0, sizeof(mz_zip_file));
     mz_zip_writer_set_compress_level(_zip, MZ_COMPRESS_LEVEL_NORMAL);
     file_info.version_madeby     = MZ_VERSION_MADEBY;
@@ -101,15 +112,32 @@ ZipWriter::add_compressed(
         std::stringstream ss;
         ss << "Cannot add file '" << file_name_in_zip << "' to ZIP.";
         throw std::runtime_error(ss.str());
-    }
+    }*/
+
+    zip_fileinfo zfi;
+    memset(&zfi, 0, sizeof(zip_fileinfo));
+    zipOpenNewFileInZip64(
+        _zip,
+        file_name_in_zip.c_str(),
+        &zfi,
+        nullptr,
+        0,
+        nullptr,
+        0,
+        nullptr,
+        Z_DEFLATED,
+        Z_DEFAULT_COMPRESSION,
+        1);
+    zipWriteInFileInZip(_zip, content.c_str(), (unsigned int)content.size());
+    zipCloseFileInZip(_zip);
 }
 
 void
 ZipWriter::add_uncompressed(
     std::filesystem::path const& path,
     std::string const& file_name_in_zip)
 {
-    mz_zip_writer_set_compress_method(_zip, MZ_COMPRESS_METHOD_STORE);
+    /*mz_zip_writer_set_compress_method(_zip, MZ_COMPRESS_METHOD_STORE);
     int32_t err = mz_zip_writer_add_file(
         _zip,
         path.u8string().c_str(),
@@ -119,7 +147,32 @@ ZipWriter::add_uncompressed(
         std::stringstream ss;
         ss << "Cannot add file '" << path.u8string() << "' to ZIP.";
         throw std::runtime_error(ss.str());
-    }
+    }*/
+
+    zip_fileinfo zfi;
+    memset(&zfi, 0, sizeof(zip_fileinfo));
+    zipOpenNewFileInZip64(
+        _zip,
+        file_name_in_zip.c_str(),
+        &zfi,
+        nullptr,
+        0,
+        nullptr,
+        0,
+        nullptr,
+        0,
+        0,
+        1);
+    FILE* f = fopen(path.u8string().c_str(), "rb");
+    fseek(f, 0, SEEK_END);
+    long size = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    std::vector<uint8_t> buffer;
+    buffer.resize(size);
+    fread(buffer.data(), size, 1, f);
+    fclose(f);
+    zipWriteInFileInZip(_zip, buffer.data(), (unsigned int) buffer.size());
+    zipCloseFileInZip(_zip);
 }
 
 } // namespace
@@ -199,13 +252,14 @@ class ZipReader
 
 private:
     std::string _zip_file_name;
-    void* _zip = nullptr;
+    //void* _zip = nullptr;
+    unzFile _zip = nullptr;
 };
 
 ZipReader::ZipReader(std::string const& zip_file_name)
     : _zip_file_name(zip_file_name)
 {
-    _zip = mz_zip_reader_create();
+    /*_zip = mz_zip_reader_create();
     if (!_zip)
     {
         std::stringstream ss;
@@ -219,21 +273,30 @@ ZipReader::ZipReader(std::string const& zip_file_name)
         std::stringstream ss;
         ss << "Cannot open ZIP file: '" << zip_file_name << "'.";
         throw std::runtime_error(ss.str());
+    }*/
+
+    _zip = unzOpen64(zip_file_name.c_str());
+    if (!_zip)
+    {
+        std::stringstream ss;
+        ss << "Cannot create ZIP writer: '" << zip_file_name << "'.";
+        throw std::runtime_error(ss.str());
     }
 }
 
 ZipReader::~ZipReader()
 {
     if (_zip)
     {
-        mz_zip_reader_close(_zip);
-        mz_zip_reader_delete(&_zip);
+        //mz_zip_reader_close(_zip);
+        //mz_zip_reader_delete(&_zip);
+        unzClose(_zip);
     }
 }
 
 void ZipReader::extract(std::string const& file_name, std::string& text)
 {
-    int32_t err = mz_zip_reader_locate_entry(_zip, file_name.c_str(), 0);
+    /*int32_t err = mz_zip_reader_locate_entry(_zip, file_name.c_str(), 0);
     if (err != MZ_OK)
     {
         std::stringstream ss;
@@ -249,18 +312,61 @@ void ZipReader::extract(std::string const& file_name, std::string& text)
         std::stringstream ss;
         ss << "Cannot read file in ZIP: '" << file_name << "'.";
         throw std::runtime_error(ss.str());
-    }
+    }*/
+
+    unzLocateFile(_zip, file_name.c_str(), 0);
+    unz_file_info64 ufi; 
+    unzGetCurrentFileInfo64(_zip, &ufi, nullptr, 0, nullptr, 0, nullptr, 0);
+    unzOpenCurrentFile(_zip);
+    text.resize(ufi.uncompressed_size);
+    unzReadCurrentFile(_zip, text.data(), ufi.uncompressed_size);
+    unzCloseCurrentFile(_zip);
 }
 
 void
 ZipReader::extract_all(std::string const& output_dir)
 {
-    int32_t err = mz_zip_reader_save_all(_zip, output_dir.c_str());
+    /*int32_t err = mz_zip_reader_save_all(_zip, output_dir.c_str());
     if (err != MZ_OK)
     {
         std::stringstream ss;
         ss << "Cannot extract ZIP file: '" << _zip_file_name << "'.";
         throw std::runtime_error(ss.str());
+    }*/
+
+    if (unzGoToFirstFile(_zip) == UNZ_OK)
+    {
+        do
+        {
+            unz_file_info64 ufi;
+            std::string     fileName;
+            fileName.resize(1024);
+            unzGetCurrentFileInfo64(
+                _zip,
+                &ufi,
+                fileName.data(),
+                fileName.size(),
+                nullptr,
+                0,
+                nullptr,
+                0);
+            unzOpenCurrentFile(_zip);
+            std::vector<uint8_t> buf(ufi.uncompressed_size);
+            unzReadCurrentFile(_zip, buf.data(), ufi.uncompressed_size);
+            unzCloseCurrentFile(_zip);
+            const std::filesystem::path path =
+                std::filesystem::u8path(output_dir)
+                / std::filesystem::u8path(fileName);
+            const std::filesystem::path parentPath = path.parent_path();
+            if (!std::filesystem::exists(parentPath))
+            {
+                std::filesystem::create_directory(parentPath);
+            }
+            FILE* f = fopen(path.u8string().c_str(), "wb");
+            fwrite(buf.data(), buf.size(), 1, f);
+            fclose(f);
+
+        } while (unzGoToNextFile(_zip) == UNZ_OK);
     }
 }
 
@@ -290,6 +396,7 @@ from_otioz(
                    << "' exists, will not overwrite.";
                 throw std::runtime_error(ss.str());
             }
+            std::filesystem::create_directory(extract_path);
 
             // Extract the archive.
             zip.extract_all(extract_path.u8string());

src/opentimelineio/otioz.cpp

@@ -10,12 +10,9 @@ list(APPEND tests_opentime test_opentime)
 foreach(test ${tests_opentime})
 	add_executable(${test} utils.h utils.cpp ${test}.cpp)
 	target_link_libraries(${test} opentime)
+    target_compile_definitions(${test} PUBLIC OTIO_TESTS_DIR="${CMAKE_CURRENT_SOURCE_DIR}")
 	set_target_properties(${test} PROPERTIES FOLDER tests)
-	add_test(NAME ${test} 
-           COMMAND ${test}
-           # Set the pwd to the source directory so we can load the samples
-           # like the python tests do
-           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+	add_test(NAME ${test} COMMAND ${test})
 endforeach()
 
 list(APPEND tests_opentimelineio
@@ -32,12 +29,8 @@ list(APPEND tests_opentimelineio
     test_otioz)
 foreach(test ${tests_opentimelineio})
     add_executable(${test} utils.h utils.cpp ${test}.cpp)
-
     target_link_libraries(${test} opentimelineio)
+    target_compile_definitions(${test} PUBLIC OTIO_TESTS_DIR="${CMAKE_CURRENT_SOURCE_DIR}")
     set_target_properties(${test} PROPERTIES FOLDER tests)
-    add_test(NAME ${test} 
-           COMMAND ${test}
-           # Set the pwd to the source directory so we can load the samples
-           # like the python tests do
-           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    add_test(NAME ${test} COMMAND ${test})
 endforeach()

tests/CMakeLists.txt

@@ -27,7 +27,7 @@ main(int argc, char** argv)
 
     // Sample data paths.
     std::filesystem::path const sample_data_dir =
-        std::filesystem::current_path() / "sample_data";
+        std::filesystem::u8path(OTIO_TESTS_DIR) / "sample_data";
     std::string const screening_example_path = otio::to_unix_separators(
         (sample_data_dir / "screening_example.otio").u8string());