[Libreoffice-commits] core.git: avmedia/source external/collada2gltf
Matúš Kukan
matus.kukan at collabora.com
Wed May 14 12:31:56 PDT 2014
avmedia/source/framework/modeltools.cxx | 11
external/collada2gltf/StaticLibrary_collada2gltf.mk | 6
external/collada2gltf/UnpackedTarball_collada2gltf.mk | 5
external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3 | 8522 ++++++++++
external/collada2gltf/write-only-.dae-file-which-we-need.patch.0 | 128
5 files changed, 8671 insertions(+), 1 deletion(-)
New commits:
commit 436f2aa8208decd022069c52544169030a6913db
Author: Matúš Kukan <matus.kukan at collabora.com>
Date: Tue May 13 17:19:36 2014 +0200
Add kmz support to collada2gltf and use it.
Change-Id: I37cda0e326af00ef369c4415bcec1e03c91ce401
diff --git a/avmedia/source/framework/modeltools.cxx b/avmedia/source/framework/modeltools.cxx
index 0d51744..ea400a3 100644
--- a/avmedia/source/framework/modeltools.cxx
+++ b/avmedia/source/framework/modeltools.cxx
@@ -29,6 +29,7 @@
#ifdef ENABLE_COLLADA2GLTF
#include <COLLADA2GLTFWriter.h>
#include <GLTFAsset.h>
+#include <KMZ2Collada.h>
#endif
#include <string>
@@ -139,7 +140,7 @@ bool Embed3DModel( const uno::Reference<frame::XModel>& xModel,
{
OUString sSource = rSourceURL;
#ifdef ENABLE_COLLADA2GLTF
- if (rSourceURL.endsWith("dae"))
+ if (rSourceURL.endsWith(".dae") || rSourceURL.endsWith(".kmz"))
{
OUString sName = ::utl::TempFile::CreateTempName();
// remove .tmp extension
@@ -149,6 +150,14 @@ bool Embed3DModel( const uno::Reference<frame::XModel>& xModel,
std::shared_ptr <GLTF::GLTFAsset> asset(new GLTF::GLTFAsset());
asset->setInputFilePath(sSourcePath);
+
+ if (rSourceURL.endsWith(".kmz"))
+ {
+ std::string strDaeFilePath = GLTF::Kmz2Collada()(asset->getInputFilePath());
+ if (strDaeFilePath == "")
+ return false;
+ asset->setInputFilePath(strDaeFilePath);
+ }
asset->setBundleOutputPath(OUStringToOString( sName, RTL_TEXTENCODING_UTF8 ).getStr());
GLTF::COLLADA2GLTFWriter writer(asset);
writer.write();
diff --git a/external/collada2gltf/StaticLibrary_collada2gltf.mk b/external/collada2gltf/StaticLibrary_collada2gltf.mk
index a25f63d..0097f3f 100644
--- a/external/collada2gltf/StaticLibrary_collada2gltf.mk
+++ b/external/collada2gltf/StaticLibrary_collada2gltf.mk
@@ -50,6 +50,7 @@ $(eval $(call gb_StaticLibrary_add_generated_exception_objects,collada2gltf,\
UnpackedTarball/collada2gltf/COLLADA2GLTFWriter \
UnpackedTarball/collada2gltf/GitSHA1 \
UnpackedTarball/collada2gltf/GLTFOpenCOLLADAUtils \
+ UnpackedTarball/collada2gltf/KMZ2Collada \
UnpackedTarball/collada2gltf/assetModifiers/GLTFFlipUVModifier \
UnpackedTarball/collada2gltf/convert/meshConverter \
UnpackedTarball/collada2gltf/convert/animationConverter \
@@ -81,6 +82,11 @@ $(eval $(call gb_StaticLibrary_add_generated_exception_objects,collada2gltf,\
UnpackedTarball/collada2gltf/shaders/commonProfileShaders \
))
+$(eval $(call gb_StaticLibrary_add_generated_cobjects,collada2gltf,\
+ UnpackedTarball/collada2gltf/kmz/ioapi \
+ UnpackedTarball/collada2gltf/kmz/unzip \
+))
+
# o3dgc external library compiled from collada2gltf
$(eval $(call gb_StaticLibrary_set_include,collada2gltf,\
-I$(call gb_UnpackedTarball_get_dir,collada2gltf)/dependencies/o3dgc/src/o3dgc_common_lib/inc \
diff --git a/external/collada2gltf/UnpackedTarball_collada2gltf.mk b/external/collada2gltf/UnpackedTarball_collada2gltf.mk
index 92bc775..3112cd9 100644
--- a/external/collada2gltf/UnpackedTarball_collada2gltf.mk
+++ b/external/collada2gltf/UnpackedTarball_collada2gltf.mk
@@ -13,4 +13,9 @@ $(eval $(call gb_UnpackedTarball_set_tarball,collada2gltf,$(COLLADA2GLTF_TARBALL
$(eval $(call gb_UnpackedTarball_add_file,collada2gltf,.,external/collada2gltf/GitSHA1.cpp))
+$(eval $(call gb_UnpackedTarball_add_patches,collada2gltf,\
+ external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3 \
+ external/collada2gltf/write-only-.dae-file-which-we-need.patch.0 \
+))
+
# vim: set noet sw=4 ts=4:
diff --git a/external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3 b/external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3
new file mode 100644
index 0000000..d41a7f9
--- /dev/null
+++ b/external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3
@@ -0,0 +1,8522 @@
+From a516e4953d16a87eee3f25a3067fa8ea930d3888 Mon Sep 17 00:00:00 2001
+From: jhuan <huan at multicorewareinc.com>
+Date: Mon, 12 May 2014 15:53:39 +0800
+Subject: [PATCH 1/2] Add unzip kmz files to collada files module:
+
+---
+ converter/COLLADA2GLTF/CMakeLists.txt | 16 +-
+ converter/COLLADA2GLTF/KMZ2Collada.cpp | 121 ++
+ converter/COLLADA2GLTF/KMZ2Collada.h | 28 +
+ converter/COLLADA2GLTF/kmz/ioapi.c | 247 ++++
+ converter/COLLADA2GLTF/kmz/ioapi.h | 208 ++++
+ converter/COLLADA2GLTF/kmz/iowin32.c | 461 +++++++
+ converter/COLLADA2GLTF/kmz/iowin32.h | 28 +
+ converter/COLLADA2GLTF/kmz/unzip.c | 2125 ++++++++++++++++++++++++++++++++
+ converter/COLLADA2GLTF/kmz/unzip.h | 437 +++++++
+ converter/COLLADA2GLTF/kmz/zconf.h | 513 ++++++++
+ converter/COLLADA2GLTF/kmz/zip.c | 2007 ++++++++++++++++++++++++++++++
+ converter/COLLADA2GLTF/kmz/zip.h | 362 ++++++
+ converter/COLLADA2GLTF/kmz/zlib.h | 1768 ++++++++++++++++++++++++++
+ converter/COLLADA2GLTF/main.cpp | 19 +
+ 14 files changed, 8338 insertions(+), 2 deletions(-)
+ create mode 100644 converter/COLLADA2GLTF/KMZ2Collada.cpp
+ create mode 100644 converter/COLLADA2GLTF/KMZ2Collada.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/ioapi.c
+ create mode 100644 converter/COLLADA2GLTF/kmz/ioapi.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/iowin32.c
+ create mode 100644 converter/COLLADA2GLTF/kmz/iowin32.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/unzip.c
+ create mode 100644 converter/COLLADA2GLTF/kmz/unzip.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/zconf.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/zip.c
+ create mode 100644 converter/COLLADA2GLTF/kmz/zip.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/zlib.h
+
+diff --git a/converter/COLLADA2GLTF/CMakeLists.txt b/converter/COLLADA2GLTF/CMakeLists.txt
+index 4dffbd4..f5f6465 100644
+--- a/converter/COLLADA2GLTF/CMakeLists.txt
++++ b/converter/COLLADA2GLTF/CMakeLists.txt
+@@ -26,7 +26,7 @@ get_git_head_revision(GIT_REFSPEC GIT_SHA1)
+
+ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/GitSHA1.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/GitSHA1.cpp" @ONLY)
+
+-set(TARGET_LIBS GeneratedSaxParser_static OpenCOLLADABaseUtils_static UTF_static ftoa_static MathMLSolver_static OpenCOLLADASaxFrameworkLoader_static OpenCOLLADAFramework_static buffer_static)
++set(TARGET_LIBS GeneratedSaxParser_static OpenCOLLADABaseUtils_static UTF_static ftoa_static MathMLSolver_static OpenCOLLADASaxFrameworkLoader_static OpenCOLLADAFramework_static buffer_static zlib zlibstat)
+
+ if (NOT WIN32)
+ set(CMAKE_FIND_LIBRARY_SUFFIXES .so .a .dylib)
+@@ -34,6 +34,7 @@ endif()
+
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/GLTF)
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/JSON)
++include_directories(${COLLADA2GLTF_SOURCE_DIR}/kmz)
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/shaders)
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/helpers)
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/convert)
+@@ -65,6 +66,8 @@ if (NOT WIN32)
+ endif()
+
+ link_directories(${COLLADA2GLTF_BINARY_DIR}/lib)
++link_directories(${COLLADA2GLTF_SOURCE_DIR}/kmz)
++
+
+ if (WIN32)
+ add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+@@ -85,6 +88,15 @@ set(GLTF_SOURCES main.cpp
+ GLTFOpenCOLLADA.h
+ GLTFOpenCOLLADAUtils.h
+ GLTFOpenCOLLADAUtils.cpp
++
++ KMZ2Collada.h
++ KMZ2Collada.cpp
++ kmz/zlib.h
++ kmz/unzip.h
++ kmz/unzip.c
++ kmz/ioapi.h
++ kmz/ioapi.c
++
+
+ GLTF/GLTFAccessorCache.cpp
+ GLTF/GLTFAccessorCache.h
+@@ -173,7 +185,7 @@ LIST(APPEND TARGET_LIBS ${PNG_LIBRARY} ${ZLIB_LIBRARY})
+ endif()
+
+ if (USE_OPEN3DGC)
+-LIST(APPEND TARGET_LIBS o3dgc_common_lib o3dgc_enc_lib o3dgc_dec_lib)
++LIST(APPEND TARGET_LIBS o3dgc_common_lib o3dgc_enc_lib o3dgc_dec_lib zlib)
+ endif()
+
+ IF("${CMAKE_SYSTEM}" MATCHES "Linux")
+diff --git a/converter/COLLADA2GLTF/KMZ2Collada.cpp b/converter/COLLADA2GLTF/KMZ2Collada.cpp
+new file mode 100644
+index 0000000..d193784
+--- /dev/null
++++ b/converter/COLLADA2GLTF/KMZ2Collada.cpp
+@@ -0,0 +1,121 @@
++#include "KMZ2Collada.h"
++#include "kmz/unzip.h"
++#include "kmz/ioapi.h"
++
++#include <direct.h>
++
++using namespace std;
++
++namespace GLTF{
++ Kmz2Collada::Kmz2Collada() {
++
++ }
++ Kmz2Collada::~Kmz2Collada() {
++
++ }
++
++ void Kmz2Collada::setFileFolder(std::string& strSrc) {
++ std::string strFolderPath = "";
++ char *pFolderName = new char[strSrc.size()];
++
++ for (unsigned int i = 0; i < strSrc.size(); i++) {
++ if (strSrc[i] == '\\' || strSrc[i] == '/') {
++ pFolderName[i] = '\0';
++ strFolderPath = strKmzPath + pFolderName;
++ _mkdir(strFolderPath.c_str());
++ }
++ pFolderName[i] = strSrc[i];
++ }
++ strSrc = strKmzPath +strSrc;
++
++ delete[] pFolderName;
++ }
++ void Kmz2Collada::getFilePath(std::string& strSrc) {
++ char *pTemporaryContent = new char[strSrc.size()+1];
++ std::string strFilePath;
++
++ for (unsigned int ipos = 0; ipos < strSrc.size(); ipos ++) {
++ if (strSrc[ipos] == '\\' || strSrc[ipos] == '/') {
++ pTemporaryContent[ipos] = '\0';
++ strFilePath = pTemporaryContent;
++ _mkdir(strFilePath.c_str());
++ }
++ pTemporaryContent[ipos] = strSrc[ipos];
++ }
++
++ if (strFilePath != "")
++ strFilePath += '\\';
++ strSrc = strFilePath;
++ strKmzPath = strSrc;
++
++ delete[] pTemporaryContent;
++ }
++
++ std::string Kmz2Collada::operator()(std::string strInputFile) {
++ int iFileLength;
++ unzFile zFile;
++ unsigned int num = 512;
++ unz_file_info64 zFileInfo;
++ unz_global_info64 zGlobalInfo;
++ char *pFileName = new char[num];
++
++ zFile = unzOpen64(strInputFile.c_str());
++
++ if (zFile == NULL) {
++ printf("Open Kmz file error\n");
++ return "";
++ }
++ getFilePath(strInputFile);
++
++ if (UNZ_OK != unzGetGlobalInfo64(zFile, &zGlobalInfo)) {
++ printf("Parsing file error\n");
++ return "";
++ }
++
++ for (int i = 0; i < zGlobalInfo.number_entry; i++) {
++ if (UNZ_OK != unzGetCurrentFileInfo64(zFile, &zFileInfo,
++ pFileName, num, NULL, 0, NULL, 0)) {
++ printf("Read file error\n");
++ return "";
++ }
++ std::string strFilePath = pFileName;
++ setFileFolder(strFilePath);
++ if (strstr(strFilePath.c_str(), ".dae"))
++ strDaePath = strFilePath;
++
++ FILE *fp = fopen(strFilePath.c_str(),"wb");
++
++ if (UNZ_OK != unzOpenCurrentFile(zFile)) {
++ printf("Open current file error");
++ return "";
++ }
++
++ iFileLength = (int)zFileInfo.uncompressed_size;
++ char *pFileData = new char[iFileLength];
++ int len = 1;
++
++ while (len) {
++ len = unzReadCurrentFile(zFile, (voidp)pFileData,
++ iFileLength - 1);
++ pFileData[len] = '\0';
++
++ if ( len <= 0) {
++ break;
++ }
++ fwrite(pFileData, 1, len, fp);
++ }
++ fclose(fp);
++ delete[] pFileData;
++ pFileData = NULL;
++
++ unzGoToNextFile(zFile);
++ }
++ unzCloseCurrentFile(zFile);
++
++ delete[] pFileName;
++ pFileName = NULL;
++
++ return strDaePath;
++ }
++
++}
+\ No newline at end of file
+diff --git a/converter/COLLADA2GLTF/KMZ2Collada.h b/converter/COLLADA2GLTF/KMZ2Collada.h
+new file mode 100644
+index 0000000..5e8bdef
+--- /dev/null
++++ b/converter/COLLADA2GLTF/KMZ2Collada.h
+@@ -0,0 +1,28 @@
++#ifndef __KMZ2COLLADA_H__
++#define __KMZ2COLLADA_H__
++
++#include <string>
++
++namespace GLTF{
++ class Kmz2Collada
++ {
++ public:
++ Kmz2Collada();
++ ~Kmz2Collada();
++
++ /** get the kmz file path and set folder.*/
++ void setFileFolder(std::string& strSrc);
++
++ /** get kmz file path.*/
++ void getFilePath(std::string& strSrc);
++
++ /** copy function.*/
++ std::string operator()(std::string strInputFile);
++
++ private:
++ std::string strDaePath;
++ std::string strKmzPath;
++ };
++
++}
++#endif
+\ No newline at end of file
+diff --git a/converter/COLLADA2GLTF/kmz/ioapi.c b/converter/COLLADA2GLTF/kmz/ioapi.c
+new file mode 100644
+index 0000000..7f5c191
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/ioapi.c
+@@ -0,0 +1,247 @@
++/* ioapi.h -- IO base function header for compress/uncompress .zip
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++*/
++
++#if defined(_WIN32) && (!(defined(_CRT_SECURE_NO_WARNINGS)))
++ #define _CRT_SECURE_NO_WARNINGS
++#endif
++
++#if defined(__APPLE__) || defined(IOAPI_NO_64)
++// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
++#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
++#define FTELLO_FUNC(stream) ftello(stream)
++#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
++#else
++#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
++#define FTELLO_FUNC(stream) ftello64(stream)
++#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
++#endif
++
++
++#include "ioapi.h"
++
++voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
++{
++ if (pfilefunc->zfile_func64.zopen64_file != NULL)
++ return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
++ else
++ {
++ return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
++ }
++}
++
++long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
++{
++ if (pfilefunc->zfile_func64.zseek64_file != NULL)
++ return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
++ else
++ {
++ uLong offsetTruncated = (uLong)offset;
++ if (offsetTruncated != offset)
++ return -1;
++ else
++ return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
++ }
++}
++
++ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
++{
++ if (pfilefunc->zfile_func64.zseek64_file != NULL)
++ return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
++ else
++ {
++ uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
++ if ((tell_uLong) == MAXU32)
++ return (ZPOS64_T)-1;
++ else
++ return tell_uLong;
++ }
++}
++
++void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
++{
++ p_filefunc64_32->zfile_func64.zopen64_file = NULL;
++ p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
++ p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
++ p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
++ p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
++ p_filefunc64_32->zfile_func64.ztell64_file = NULL;
++ p_filefunc64_32->zfile_func64.zseek64_file = NULL;
++ p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
++ p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
++ p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
++ p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
++ p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
++}
++
++
++
++static voidpf ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
++static uLong ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
++static uLong ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
++static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
++static long ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
++static int ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
++static int ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
++
++static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
++{
++ FILE* file = NULL;
++ const char* mode_fopen = NULL;
++ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
++ mode_fopen = "rb";
++ else
++ if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
++ mode_fopen = "r+b";
++ else
++ if (mode & ZLIB_FILEFUNC_MODE_CREATE)
++ mode_fopen = "wb";
++
++ if ((filename!=NULL) && (mode_fopen != NULL))
++ file = fopen(filename, mode_fopen);
++ return file;
++}
++
++static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
++{
++ FILE* file = NULL;
++ const char* mode_fopen = NULL;
++ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
++ mode_fopen = "rb";
++ else
++ if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
++ mode_fopen = "r+b";
++ else
++ if (mode & ZLIB_FILEFUNC_MODE_CREATE)
++ mode_fopen = "wb";
++
++ if ((filename!=NULL) && (mode_fopen != NULL))
++ file = FOPEN_FUNC((const char*)filename, mode_fopen);
++ return file;
++}
++
++
++static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
++{
++ uLong ret;
++ ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
++ return ret;
++}
++
++static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
++{
++ uLong ret;
++ ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
++ return ret;
++}
++
++static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
++{
++ long ret;
++ ret = ftell((FILE *)stream);
++ return ret;
++}
++
++
++static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
++{
++ ZPOS64_T ret;
++ ret = FTELLO_FUNC((FILE *)stream);
++ return ret;
++}
++
++static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offset, int origin)
++{
++ int fseek_origin=0;
++ long ret;
++ switch (origin)
++ {
++ case ZLIB_FILEFUNC_SEEK_CUR :
++ fseek_origin = SEEK_CUR;
++ break;
++ case ZLIB_FILEFUNC_SEEK_END :
++ fseek_origin = SEEK_END;
++ break;
++ case ZLIB_FILEFUNC_SEEK_SET :
++ fseek_origin = SEEK_SET;
++ break;
++ default: return -1;
++ }
++ ret = 0;
++ if (fseek((FILE *)stream, offset, fseek_origin) != 0)
++ ret = -1;
++ return ret;
++}
++
++static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)
++{
++ int fseek_origin=0;
++ long ret;
++ switch (origin)
++ {
++ case ZLIB_FILEFUNC_SEEK_CUR :
++ fseek_origin = SEEK_CUR;
++ break;
++ case ZLIB_FILEFUNC_SEEK_END :
++ fseek_origin = SEEK_END;
++ break;
++ case ZLIB_FILEFUNC_SEEK_SET :
++ fseek_origin = SEEK_SET;
++ break;
++ default: return -1;
++ }
++ ret = 0;
++
++ if(FSEEKO_FUNC((FILE *)stream, offset, fseek_origin) != 0)
++ ret = -1;
++
++ return ret;
++}
++
++
++static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
++{
++ int ret;
++ ret = fclose((FILE *)stream);
++ return ret;
++}
++
++static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
++{
++ int ret;
++ ret = ferror((FILE *)stream);
++ return ret;
++}
++
++void fill_fopen_filefunc (pzlib_filefunc_def)
++ zlib_filefunc_def* pzlib_filefunc_def;
++{
++ pzlib_filefunc_def->zopen_file = fopen_file_func;
++ pzlib_filefunc_def->zread_file = fread_file_func;
++ pzlib_filefunc_def->zwrite_file = fwrite_file_func;
++ pzlib_filefunc_def->ztell_file = ftell_file_func;
++ pzlib_filefunc_def->zseek_file = fseek_file_func;
++ pzlib_filefunc_def->zclose_file = fclose_file_func;
++ pzlib_filefunc_def->zerror_file = ferror_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
++
++void fill_fopen64_filefunc (zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen64_file = fopen64_file_func;
++ pzlib_filefunc_def->zread_file = fread_file_func;
++ pzlib_filefunc_def->zwrite_file = fwrite_file_func;
++ pzlib_filefunc_def->ztell64_file = ftell64_file_func;
++ pzlib_filefunc_def->zseek64_file = fseek64_file_func;
++ pzlib_filefunc_def->zclose_file = fclose_file_func;
++ pzlib_filefunc_def->zerror_file = ferror_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
+diff --git a/converter/COLLADA2GLTF/kmz/ioapi.h b/converter/COLLADA2GLTF/kmz/ioapi.h
+new file mode 100644
+index 0000000..8dcbdb0
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/ioapi.h
+@@ -0,0 +1,208 @@
++/* ioapi.h -- IO base function header for compress/uncompress .zip
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++ Changes
++
++ Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
++ Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
++ More if/def section may be needed to support other platforms
++ Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
++ (but you should use iowin32.c for windows instead)
++
++*/
++
++#ifndef _ZLIBIOAPI64_H
++#define _ZLIBIOAPI64_H
++
++#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
++
++ // Linux needs this to support file operation on files larger then 4+GB
++ // But might need better if/def to select just the platforms that needs them.
++
++ #ifndef __USE_FILE_OFFSET64
++ #define __USE_FILE_OFFSET64
++ #endif
++ #ifndef __USE_LARGEFILE64
++ #define __USE_LARGEFILE64
++ #endif
++ #ifndef _LARGEFILE64_SOURCE
++ #define _LARGEFILE64_SOURCE
++ #endif
++ #ifndef _FILE_OFFSET_BIT
++ #define _FILE_OFFSET_BIT 64
++ #endif
++
++#endif
++
++#include <stdio.h>
++#include <stdlib.h>
++#include "zlib.h"
++
++#if defined(USE_FILE32API)
++#define fopen64 fopen
++#define ftello64 ftell
++#define fseeko64 fseek
++#else
++#ifdef __FreeBSD__
++#define fopen64 fopen
++#define ftello64 ftello
++#define fseeko64 fseeko
++#endif
++#ifdef _MSC_VER
++ #define fopen64 fopen
++ #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
++ #define ftello64 _ftelli64
++ #define fseeko64 _fseeki64
++ #else // old MSC
++ #define ftello64 ftell
++ #define fseeko64 fseek
++ #endif
++#endif
++#endif
++
++/*
++#ifndef ZPOS64_T
++ #ifdef _WIN32
++ #define ZPOS64_T fpos_t
++ #else
++ #include <stdint.h>
++ #define ZPOS64_T uint64_t
++ #endif
++#endif
++*/
++
++#ifdef HAVE_MINIZIP64_CONF_H
++#include "mz64conf.h"
++#endif
++
++/* a type choosen by DEFINE */
++#ifdef HAVE_64BIT_INT_CUSTOM
++typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T;
++#else
++#ifdef HAS_STDINT_H
++#include "stdint.h"
++typedef uint64_t ZPOS64_T;
++#else
++
++/* Maximum unsigned 32-bit value used as placeholder for zip64 */
++#define MAXU32 0xffffffff
++
++#if defined(_MSC_VER) || defined(__BORLANDC__)
++typedef unsigned __int64 ZPOS64_T;
++#else
++typedef unsigned long long int ZPOS64_T;
++#endif
++#endif
++#endif
++
++
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++#define ZLIB_FILEFUNC_SEEK_CUR (1)
++#define ZLIB_FILEFUNC_SEEK_END (2)
++#define ZLIB_FILEFUNC_SEEK_SET (0)
++
++#define ZLIB_FILEFUNC_MODE_READ (1)
++#define ZLIB_FILEFUNC_MODE_WRITE (2)
++#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
++
++#define ZLIB_FILEFUNC_MODE_EXISTING (4)
++#define ZLIB_FILEFUNC_MODE_CREATE (8)
++
++
++#ifndef ZCALLBACK
++ #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
++ #define ZCALLBACK CALLBACK
++ #else
++ #define ZCALLBACK
++ #endif
++#endif
++
++
++
++
++typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
++typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
++typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
++typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
++typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
++
++typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
++typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
++
++
++/* here is the "old" 32 bits structure structure */
++typedef struct zlib_filefunc_def_s
++{
++ open_file_func zopen_file;
++ read_file_func zread_file;
++ write_file_func zwrite_file;
++ tell_file_func ztell_file;
++ seek_file_func zseek_file;
++ close_file_func zclose_file;
++ testerror_file_func zerror_file;
++ voidpf opaque;
++} zlib_filefunc_def;
++
++typedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream));
++typedef long (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
++typedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, const void* filename, int mode));
++
++typedef struct zlib_filefunc64_def_s
++{
++ open64_file_func zopen64_file;
++ read_file_func zread_file;
++ write_file_func zwrite_file;
++ tell64_file_func ztell64_file;
++ seek64_file_func zseek64_file;
++ close_file_func zclose_file;
++ testerror_file_func zerror_file;
++ voidpf opaque;
++} zlib_filefunc64_def;
++
++void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
++void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
++
++/* now internal definition, only for zip.c and unzip.h */
++typedef struct zlib_filefunc64_32_def_s
++{
++ zlib_filefunc64_def zfile_func64;
++ open_file_func zopen32_file;
++ tell_file_func ztell32_file;
++ seek_file_func zseek32_file;
++} zlib_filefunc64_32_def;
++
++
++#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
++#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
++//#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
++//#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
++#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream))
++#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream))
++
++voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
++long call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
++ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
++
++void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32);
++
++#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode)))
++#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream)))
++#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+diff --git a/converter/COLLADA2GLTF/kmz/iowin32.c b/converter/COLLADA2GLTF/kmz/iowin32.c
+new file mode 100644
+index 0000000..a46d96c
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/iowin32.c
+@@ -0,0 +1,461 @@
++/* iowin32.c -- IO base function header for compress/uncompress .zip
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++*/
++
++#include <stdlib.h>
++
++#include "zlib.h"
++#include "ioapi.h"
++#include "iowin32.h"
++
++#ifndef INVALID_HANDLE_VALUE
++#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
++#endif
++
++#ifndef INVALID_SET_FILE_POINTER
++#define INVALID_SET_FILE_POINTER ((DWORD)-1)
++#endif
++
++
++#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
++#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
++#define IOWIN32_USING_WINRT_API 1
++#endif
++#endif
++
++voidpf ZCALLBACK win32_open_file_func OF((voidpf opaque, const char* filename, int mode));
++uLong ZCALLBACK win32_read_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
++uLong ZCALLBACK win32_write_file_func OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
++ZPOS64_T ZCALLBACK win32_tell64_file_func OF((voidpf opaque, voidpf stream));
++long ZCALLBACK win32_seek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
++int ZCALLBACK win32_close_file_func OF((voidpf opaque, voidpf stream));
++int ZCALLBACK win32_error_file_func OF((voidpf opaque, voidpf stream));
++
++typedef struct
++{
++ HANDLE hf;
++ int error;
++} WIN32FILE_IOWIN;
++
++
++static void win32_translate_open_mode(int mode,
++ DWORD* lpdwDesiredAccess,
++ DWORD* lpdwCreationDisposition,
++ DWORD* lpdwShareMode,
++ DWORD* lpdwFlagsAndAttributes)
++{
++ *lpdwDesiredAccess = *lpdwShareMode = *lpdwFlagsAndAttributes = *lpdwCreationDisposition = 0;
++
++ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
++ {
++ *lpdwDesiredAccess = GENERIC_READ;
++ *lpdwCreationDisposition = OPEN_EXISTING;
++ *lpdwShareMode = FILE_SHARE_READ;
++ }
++ else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
++ {
++ *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
++ *lpdwCreationDisposition = OPEN_EXISTING;
++ }
++ else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
++ {
++ *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
++ *lpdwCreationDisposition = CREATE_ALWAYS;
++ }
++}
++
++static voidpf win32_build_iowin(HANDLE hFile)
++{
++ voidpf ret=NULL;
++
++ if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
++ {
++ WIN32FILE_IOWIN w32fiow;
++ w32fiow.hf = hFile;
++ w32fiow.error = 0;
++ ret = malloc(sizeof(WIN32FILE_IOWIN));
++
++ if (ret==NULL)
++ CloseHandle(hFile);
++ else
++ *((WIN32FILE_IOWIN*)ret) = w32fiow;
++ }
++ return ret;
++}
++
++voidpf ZCALLBACK win32_open64_file_func (voidpf opaque,const void* filename,int mode)
++{
++ const char* mode_fopen = NULL;
++ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
++ HANDLE hFile = NULL;
++
++ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
++
++#ifdef IOWIN32_USING_WINRT_API
++#ifdef UNICODE
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ {
++ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
++ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
++ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++ }
++#endif
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
++#endif
++
++ return win32_build_iowin(hFile);
++}
++
++
++voidpf ZCALLBACK win32_open64_file_funcA (voidpf opaque,const void* filename,int mode)
++{
++ const char* mode_fopen = NULL;
++ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
++ HANDLE hFile = NULL;
++
++ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
++
++#ifdef IOWIN32_USING_WINRT_API
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ {
++ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
++ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
++ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++ }
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
++#endif
++
++ return win32_build_iowin(hFile);
++}
++
++
++voidpf ZCALLBACK win32_open64_file_funcW (voidpf opaque,const void* filename,int mode)
++{
++ const char* mode_fopen = NULL;
++ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
++ HANDLE hFile = NULL;
++
++ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
++
++#ifdef IOWIN32_USING_WINRT_API
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition,NULL);
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
++#endif
++
++ return win32_build_iowin(hFile);
++}
++
++
++voidpf ZCALLBACK win32_open_file_func (voidpf opaque,const char* filename,int mode)
++{
++ const char* mode_fopen = NULL;
++ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
++ HANDLE hFile = NULL;
++
++ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
++
++#ifdef IOWIN32_USING_WINRT_API
++#ifdef UNICODE
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ {
++ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
++ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
++ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++ }
++#endif
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
++#endif
++
++ return win32_build_iowin(hFile);
++}
++
++
++uLong ZCALLBACK win32_read_file_func (voidpf opaque, voidpf stream, void* buf,uLong size)
++{
++ uLong ret=0;
++ HANDLE hFile = NULL;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++
++ if (hFile != NULL)
++ {
++ if (!ReadFile(hFile, buf, size, &ret, NULL))
++ {
++ DWORD dwErr = GetLastError();
++ if (dwErr == ERROR_HANDLE_EOF)
++ dwErr = 0;
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ }
++ }
++
++ return ret;
++}
++
++
++uLong ZCALLBACK win32_write_file_func (voidpf opaque,voidpf stream,const void* buf,uLong size)
++{
++ uLong ret=0;
++ HANDLE hFile = NULL;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++
++ if (hFile != NULL)
++ {
++ if (!WriteFile(hFile, buf, size, &ret, NULL))
++ {
++ DWORD dwErr = GetLastError();
++ if (dwErr == ERROR_HANDLE_EOF)
++ dwErr = 0;
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ }
++ }
++
++ return ret;
++}
++
++static BOOL MySetFilePointerEx(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod)
++{
++#ifdef IOWIN32_USING_WINRT_API
++ return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod);
++#else
++ LONG lHigh = pos.HighPart;
++ DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, FILE_CURRENT);
++ BOOL fOk = TRUE;
++ if (dwNewPos == 0xFFFFFFFF)
++ if (GetLastError() != NO_ERROR)
++ fOk = FALSE;
++ if ((newPos != NULL) && (fOk))
++ {
++ newPos->LowPart = dwNewPos;
++ newPos->HighPart = lHigh;
++ }
++ return fOk;
++#endif
++}
++
++long ZCALLBACK win32_tell_file_func (voidpf opaque,voidpf stream)
++{
++ long ret=-1;
++ HANDLE hFile = NULL;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++ if (hFile != NULL)
++ {
++ LARGE_INTEGER pos;
++ pos.QuadPart = 0;
++
++ if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
++ {
++ DWORD dwErr = GetLastError();
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ ret = -1;
++ }
++ else
++ ret=(long)pos.LowPart;
++ }
++ return ret;
++}
++
++ZPOS64_T ZCALLBACK win32_tell64_file_func (voidpf opaque, voidpf stream)
++{
++ ZPOS64_T ret= (ZPOS64_T)-1;
++ HANDLE hFile = NULL;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream)->hf;
++
++ if (hFile)
++ {
++ LARGE_INTEGER pos;
++ pos.QuadPart = 0;
++
++ if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
++ {
++ DWORD dwErr = GetLastError();
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ ret = (ZPOS64_T)-1;
++ }
++ else
++ ret=pos.QuadPart;
++ }
++ return ret;
++}
++
++
++long ZCALLBACK win32_seek_file_func (voidpf opaque,voidpf stream,uLong offset,int origin)
++{
++ DWORD dwMoveMethod=0xFFFFFFFF;
++ HANDLE hFile = NULL;
++
++ long ret=-1;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++ switch (origin)
++ {
++ case ZLIB_FILEFUNC_SEEK_CUR :
++ dwMoveMethod = FILE_CURRENT;
++ break;
++ case ZLIB_FILEFUNC_SEEK_END :
++ dwMoveMethod = FILE_END;
++ break;
++ case ZLIB_FILEFUNC_SEEK_SET :
++ dwMoveMethod = FILE_BEGIN;
++ break;
++ default: return -1;
++ }
++
++ if (hFile != NULL)
++ {
++ LARGE_INTEGER pos;
++ pos.QuadPart = offset;
++ if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
++ {
++ DWORD dwErr = GetLastError();
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ ret = -1;
++ }
++ else
++ ret=0;
++ }
++ return ret;
++}
++
++long ZCALLBACK win32_seek64_file_func (voidpf opaque, voidpf stream,ZPOS64_T offset,int origin)
++{
++ DWORD dwMoveMethod=0xFFFFFFFF;
++ HANDLE hFile = NULL;
++ long ret=-1;
++
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream)->hf;
++
++ switch (origin)
++ {
++ case ZLIB_FILEFUNC_SEEK_CUR :
++ dwMoveMethod = FILE_CURRENT;
++ break;
++ case ZLIB_FILEFUNC_SEEK_END :
++ dwMoveMethod = FILE_END;
++ break;
++ case ZLIB_FILEFUNC_SEEK_SET :
++ dwMoveMethod = FILE_BEGIN;
++ break;
++ default: return -1;
++ }
++
++ if (hFile)
++ {
++ LARGE_INTEGER pos;
++ pos.QuadPart = offset;
++ if (!MySetFilePointerEx(hFile, pos, NULL, FILE_CURRENT))
++ {
++ DWORD dwErr = GetLastError();
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ ret = -1;
++ }
++ else
++ ret=0;
++ }
++ return ret;
++}
++
++int ZCALLBACK win32_close_file_func (voidpf opaque, voidpf stream)
++{
++ int ret=-1;
++
++ if (stream!=NULL)
++ {
++ HANDLE hFile;
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++ if (hFile != NULL)
++ {
++ CloseHandle(hFile);
++ ret=0;
++ }
++ free(stream);
++ }
++ return ret;
++}
++
++int ZCALLBACK win32_error_file_func (voidpf opaque,voidpf stream)
++{
++ int ret=-1;
++ if (stream!=NULL)
++ {
++ ret = ((WIN32FILE_IOWIN*)stream) -> error;
++ }
++ return ret;
++}
++
++void fill_win32_filefunc (zlib_filefunc_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen_file = win32_open_file_func;
++ pzlib_filefunc_def->zread_file = win32_read_file_func;
++ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
++ pzlib_filefunc_def->ztell_file = win32_tell_file_func;
++ pzlib_filefunc_def->zseek_file = win32_seek_file_func;
++ pzlib_filefunc_def->zclose_file = win32_close_file_func;
++ pzlib_filefunc_def->zerror_file = win32_error_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
++
++void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
++ pzlib_filefunc_def->zread_file = win32_read_file_func;
++ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
++ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
++ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
++ pzlib_filefunc_def->zclose_file = win32_close_file_func;
++ pzlib_filefunc_def->zerror_file = win32_error_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
++
++
++void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
++ pzlib_filefunc_def->zread_file = win32_read_file_func;
++ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
++ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
++ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
++ pzlib_filefunc_def->zclose_file = win32_close_file_func;
++ pzlib_filefunc_def->zerror_file = win32_error_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
++
++
++void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
++ pzlib_filefunc_def->zread_file = win32_read_file_func;
++ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
++ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
++ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
++ pzlib_filefunc_def->zclose_file = win32_close_file_func;
++ pzlib_filefunc_def->zerror_file = win32_error_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
+diff --git a/converter/COLLADA2GLTF/kmz/iowin32.h b/converter/COLLADA2GLTF/kmz/iowin32.h
+new file mode 100644
+index 0000000..0ca0969
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/iowin32.h
+@@ -0,0 +1,28 @@
++/* iowin32.h -- IO base function header for compress/uncompress .zip
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++*/
++
++#include <windows.h>
++
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
++void fill_win32_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def));
++void fill_win32_filefunc64A OF((zlib_filefunc64_def* pzlib_filefunc_def));
++void fill_win32_filefunc64W OF((zlib_filefunc64_def* pzlib_filefunc_def));
++
++#ifdef __cplusplus
++}
++#endif
+diff --git a/converter/COLLADA2GLTF/kmz/unzip.c b/converter/COLLADA2GLTF/kmz/unzip.c
+new file mode 100644
+index 0000000..9093504
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/unzip.c
+@@ -0,0 +1,2125 @@
++/* unzip.c -- IO for uncompress .zip files using zlib
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications of Unzip for Zip64
++ Copyright (C) 2007-2008 Even Rouault
++
++ Modifications for Zip64 support on both zip and unzip
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++
++ ------------------------------------------------------------------------------------
++ Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
++ compatibility with older software. The following is from the original crypt.c.
++ Code woven in by Terry Thorsen 1/2003.
++
++ Copyright (c) 1990-2000 Info-ZIP. All rights reserved.
++
++ See the accompanying file LICENSE, version 2000-Apr-09 or later
++ (the contents of which are also included in zip.h) for terms of use.
++ If, for some reason, all these files are missing, the Info-ZIP license
++ also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
++
++ crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h]
++
++ The encryption/decryption parts of this source code (as opposed to the
++ non-echoing password parts) were originally written in Europe. The
++ whole source package can be freely distributed, including from the USA.
++ (Prior to January 2000, re-export from the US was a violation of US law.)
++
++ This encryption code is a direct transcription of the algorithm from
++ Roger Schlafly, described by Phil Katz in the file appnote.txt. This
++ file (appnote.txt) is distributed with the PKZIP program (even in the
++ version without encryption capabilities).
++
++ ------------------------------------------------------------------------------------
++
++ Changes in unzip.c
++
++ 2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos
++ 2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz*
++ 2007-2008 - Even Rouault - Remove old C style function prototypes
++ 2007-2008 - Even Rouault - Add unzip support for ZIP64
++
++ Copyright (C) 2007-2008 Even Rouault
++
++
++ Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again).
++ Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G
++ should only read the compressed/uncompressed size from the Zip64 format if
++ the size from normal header was 0xFFFFFFFF
++ Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant
++ Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)
++ Patch created by Daniel Borca
++
++ Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
++
++ Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson
++
++*/
++
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++#ifndef NOUNCRYPT
++ #define NOUNCRYPT
++#endif
++
++#include "zlib.h"
++#include "unzip.h"
++
++#ifdef STDC
++# include <stddef.h>
++# include <string.h>
++# include <stdlib.h>
++#endif
++#ifdef NO_ERRNO_H
++ extern int errno;
++#else
++# include <errno.h>
++#endif
++
++
++#ifndef local
++# define local static
++#endif
++/* compile with -Dlocal if your debugger can't find static symbols */
++
++
++#ifndef CASESENSITIVITYDEFAULT_NO
++# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
++# define CASESENSITIVITYDEFAULT_NO
++# endif
++#endif
++
++
++#ifndef UNZ_BUFSIZE
++#define UNZ_BUFSIZE (16384)
++#endif
++
++#ifndef UNZ_MAXFILENAMEINZIP
++#define UNZ_MAXFILENAMEINZIP (256)
++#endif
++
++#ifndef ALLOC
++# define ALLOC(size) (malloc(size))
++#endif
++#ifndef TRYFREE
++# define TRYFREE(p) {if (p) free(p);}
++#endif
++
++#define SIZECENTRALDIRITEM (0x2e)
++#define SIZEZIPLOCALHEADER (0x1e)
++
++
++const char unz_copyright[] =
++ " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
++
++/* unz_file_info_interntal contain internal info about a file in zipfile*/
++typedef struct unz_file_info64_internal_s
++{
++ ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */
++} unz_file_info64_internal;
++
++
++/* file_in_zip_read_info_s contain internal information about a file in zipfile,
++ when reading and decompress it */
++typedef struct
++{
++ char *read_buffer; /* internal buffer for compressed data */
++ z_stream stream; /* zLib stream structure for inflate */
++
++#ifdef HAVE_BZIP2
++ bz_stream bstream; /* bzLib stream structure for bziped */
++#endif
++
++ ZPOS64_T pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
++ uLong stream_initialised; /* flag set if stream structure is initialised*/
++
++ ZPOS64_T offset_local_extrafield;/* offset of the local extra field */
++ uInt size_local_extrafield;/* size of the local extra field */
++ ZPOS64_T pos_local_extrafield; /* position in the local extra field in read*/
++ ZPOS64_T total_out_64;
++
++ uLong crc32; /* crc32 of all data uncompressed */
++ uLong crc32_wait; /* crc32 we must obtain after decompress all */
++ ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */
++ ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/
++ zlib_filefunc64_32_def z_filefunc;
++ voidpf filestream; /* io structore of the zipfile */
++ uLong compression_method; /* compression method (0==store) */
++ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
++ int raw;
++} file_in_zip64_read_info_s;
++
++
++/* unz64_s contain internal information about the zipfile
++*/
++typedef struct
++{
++ zlib_filefunc64_32_def z_filefunc;
++ int is64bitOpenFunction;
++ voidpf filestream; /* io structore of the zipfile */
++ unz_global_info64 gi; /* public global information */
++ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
++ ZPOS64_T num_file; /* number of the current file in the zipfile*/
++ ZPOS64_T pos_in_central_dir; /* pos of the current file in the central dir*/
++ ZPOS64_T current_file_ok; /* flag about the usability of the current file*/
++ ZPOS64_T central_pos; /* position of the beginning of the central dir*/
++
++ ZPOS64_T size_central_dir; /* size of the central directory */
++ ZPOS64_T offset_central_dir; /* offset of start of central directory with
++ respect to the starting disk number */
++
++ unz_file_info64 cur_file_info; /* public info about the current file in zip*/
++ unz_file_info64_internal cur_file_info_internal; /* private info about it*/
++ file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current
++ file if we are decompressing it */
++ int encrypted;
++
++ int isZip64;
++
++# ifndef NOUNCRYPT
++ unsigned long keys[3]; /* keys defining the pseudo-random sequence */
++ const z_crc_t* pcrc_32_tab;
++# endif
++} unz64_s;
++
++
++#ifndef NOUNCRYPT
++#include "crypt.h"
++#endif
++
++/* ===========================================================================
++ Read a byte from a gz_stream; update next_in and avail_in. Return EOF
++ for end of file.
++ IN assertion: the stream s has been sucessfully opened for reading.
++*/
++
++
++local int unz64local_getByte OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ int *pi));
++
++local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)
++{
++ unsigned char c;
++ int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
++ if (err==1)
++ {
++ *pi = (int)c;
++ return UNZ_OK;
++ }
++ else
++ {
++ if (ZERROR64(*pzlib_filefunc_def,filestream))
++ return UNZ_ERRNO;
++ else
++ return UNZ_EOF;
++ }
++}
++
++
++/* ===========================================================================
++ Reads a long in LSB order from the given gz_stream. Sets
++*/
++local int unz64local_getShort OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ uLong *pX));
++
++local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ uLong *pX)
++{
++ uLong x ;
++ int i = 0;
++ int err;
++
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (uLong)i;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((uLong)i)<<8;
++
++ if (err==UNZ_OK)
++ *pX = x;
++ else
++ *pX = 0;
++ return err;
++}
++
++local int unz64local_getLong OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ uLong *pX));
++
++local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ uLong *pX)
++{
++ uLong x ;
++ int i = 0;
++ int err;
++
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (uLong)i;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((uLong)i)<<8;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((uLong)i)<<16;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((uLong)i)<<24;
++
++ if (err==UNZ_OK)
++ *pX = x;
++ else
++ *pX = 0;
++ return err;
++}
++
++local int unz64local_getLong64 OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ ZPOS64_T *pX));
++
++
++local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ ZPOS64_T *pX)
++{
++ ZPOS64_T x ;
++ int i = 0;
++ int err;
++
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (ZPOS64_T)i;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<8;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<16;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<24;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<32;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<40;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<48;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<56;
++
++ if (err==UNZ_OK)
++ *pX = x;
++ else
++ *pX = 0;
++ return err;
++}
++
++/* My own strcmpi / strcasecmp */
++local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)
++{
++ for (;;)
++ {
++ char c1=*(fileName1++);
++ char c2=*(fileName2++);
++ if ((c1>='a') && (c1<='z'))
++ c1 -= 0x20;
++ if ((c2>='a') && (c2<='z'))
++ c2 -= 0x20;
++ if (c1=='\0')
++ return ((c2=='\0') ? 0 : -1);
++ if (c2=='\0')
++ return 1;
++ if (c1<c2)
++ return -1;
++ if (c1>c2)
++ return 1;
++ }
++}
++
++
++#ifdef CASESENSITIVITYDEFAULT_NO
++#define CASESENSITIVITYDEFAULTVALUE 2
++#else
++#define CASESENSITIVITYDEFAULTVALUE 1
++#endif
++
++#ifndef STRCMPCASENOSENTIVEFUNCTION
++#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
++#endif
++
++/*
++ Compare two filename (fileName1,fileName2).
++ If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
++ If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
++ or strcasecmp)
++ If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
++ (like 1 on Unix, 2 on Windows)
++
++*/
++extern int ZEXPORT unzStringFileNameCompare (const char* fileName1,
++ const char* fileName2,
++ int iCaseSensitivity)
++
++{
++ if (iCaseSensitivity==0)
++ iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
++
++ if (iCaseSensitivity==1)
++ return strcmp(fileName1,fileName2);
++
++ return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
++}
++
++#ifndef BUFREADCOMMENT
++#define BUFREADCOMMENT (0x400)
++#endif
++
++/*
++ Locate the Central directory of a zipfile (at the end, just before
++ the global comment)
++*/
++local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
++local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
++{
++ unsigned char* buf;
++ ZPOS64_T uSizeFile;
++ ZPOS64_T uBackRead;
++ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
++ ZPOS64_T uPosFound=0;
++
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
++ return 0;
++
++
++ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
++
++ if (uMaxBack>uSizeFile)
++ uMaxBack = uSizeFile;
++
++ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
++ if (buf==NULL)
++ return 0;
++
++ uBackRead = 4;
++ while (uBackRead<uMaxBack)
++ {
++ uLong uReadSize;
++ ZPOS64_T uReadPos ;
++ int i;
++ if (uBackRead+BUFREADCOMMENT>uMaxBack)
++ uBackRead = uMaxBack;
++ else
++ uBackRead+=BUFREADCOMMENT;
++ uReadPos = uSizeFile-uBackRead ;
++
++ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
++ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ break;
++
++ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
++ break;
++
++ for (i=(int)uReadSize-3; (i--)>0;)
++ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
++ ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
++ {
++ uPosFound = uReadPos+i;
++ break;
++ }
++
++ if (uPosFound!=0)
++ break;
++ }
++ TRYFREE(buf);
++ return uPosFound;
++}
++
++
++/*
++ Locate the Central directory 64 of a zipfile (at the end, just before
++ the global comment)
++*/
++local ZPOS64_T unz64local_SearchCentralDir64 OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream));
++
++local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream)
++{
++ unsigned char* buf;
++ ZPOS64_T uSizeFile;
++ ZPOS64_T uBackRead;
++ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
++ ZPOS64_T uPosFound=0;
++ uLong uL;
++ ZPOS64_T relativeOffset;
++
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
++ return 0;
++
++
++ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
++
++ if (uMaxBack>uSizeFile)
++ uMaxBack = uSizeFile;
++
++ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
++ if (buf==NULL)
++ return 0;
++
++ uBackRead = 4;
++ while (uBackRead<uMaxBack)
++ {
++ uLong uReadSize;
++ ZPOS64_T uReadPos;
++ int i;
++ if (uBackRead+BUFREADCOMMENT>uMaxBack)
++ uBackRead = uMaxBack;
++ else
++ uBackRead+=BUFREADCOMMENT;
++ uReadPos = uSizeFile-uBackRead ;
++
++ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
++ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ break;
++
++ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
++ break;
++
++ for (i=(int)uReadSize-3; (i--)>0;)
++ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
++ ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
++ {
++ uPosFound = uReadPos+i;
++ break;
++ }
++
++ if (uPosFound!=0)
++ break;
++ }
++ TRYFREE(buf);
++ if (uPosFound == 0)
++ return 0;
++
++ /* Zip64 end of central directory locator */
++ if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return 0;
++
++ /* the signature, already checked */
++ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
++ return 0;
++
++ /* number of the disk with the start of the zip64 end of central directory */
++ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
++ return 0;
++ if (uL != 0)
++ return 0;
++
++ /* relative offset of the zip64 end of central directory record */
++ if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)
++ return 0;
++
++ /* total number of disks */
++ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
++ return 0;
++ if (uL != 1)
++ return 0;
++
++ /* Goto end of central directory record */
++ if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return 0;
++
++ /* the signature */
++ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
++ return 0;
++
++ if (uL != 0x06064b50)
++ return 0;
++
++ return relativeOffset;
++}
++
++/*
++ Open a Zip file. path contain the full pathname (by example,
++ on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
++ "zlib/zlib114.zip".
++ If the zipfile cannot be opened (file doesn't exist or in not valid), the
++ return value is NULL.
++ Else, the return value is a unzFile Handle, usable with other function
++ of this unzip package.
++*/
++local unzFile unzOpenInternal (const void *path,
++ zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
++ int is64bitOpenFunction)
++{
++ unz64_s us;
++ unz64_s *s;
++ ZPOS64_T central_pos;
++ uLong uL;
++
++ uLong number_disk; /* number of the current dist, used for
++ spaning ZIP, unsupported, always 0*/
++ uLong number_disk_with_CD; /* number the the disk with central dir, used
++ for spaning ZIP, unsupported, always 0*/
++ ZPOS64_T number_entry_CD; /* total number of entries in
++ the central dir
++ (same than number_entry on nospan) */
++
++ int err=UNZ_OK;
++
++ if (unz_copyright[0]!=' ')
++ return NULL;
++
++ us.z_filefunc.zseek32_file = NULL;
++ us.z_filefunc.ztell32_file = NULL;
++ if (pzlib_filefunc64_32_def==NULL)
++ fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);
++ else
++ us.z_filefunc = *pzlib_filefunc64_32_def;
++ us.is64bitOpenFunction = is64bitOpenFunction;
++
++
++
++ us.filestream = ZOPEN64(us.z_filefunc,
++ path,
++ ZLIB_FILEFUNC_MODE_READ |
++ ZLIB_FILEFUNC_MODE_EXISTING);
++ if (us.filestream==NULL)
++ return NULL;
++
++ central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);
++ if (central_pos)
++ {
++ uLong uS;
++ ZPOS64_T uL64;
++
++ us.isZip64 = 1;
++
++ if (ZSEEK64(us.z_filefunc, us.filestream,
++ central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err=UNZ_ERRNO;
++
++ /* the signature, already checked */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* size of zip64 end of central directory record */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* version made by */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* version needed to extract */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* number of this disk */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* number of the disk with the start of the central directory */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* total number of entries in the central directory on this disk */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* total number of entries in the central directory */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if ((number_entry_CD!=us.gi.number_entry) ||
++ (number_disk_with_CD!=0) ||
++ (number_disk!=0))
++ err=UNZ_BADZIPFILE;
++
++ /* size of the central directory */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* offset of start of central directory with respect to the
++ starting disk number */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ us.gi.size_comment = 0;
++ }
++ else
++ {
++ central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);
++ if (central_pos==0)
++ err=UNZ_ERRNO;
++
++ us.isZip64 = 0;
++
++ if (ZSEEK64(us.z_filefunc, us.filestream,
++ central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err=UNZ_ERRNO;
++
++ /* the signature, already checked */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* number of this disk */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* number of the disk with the start of the central directory */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* total number of entries in the central dir on this disk */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ us.gi.number_entry = uL;
++
++ /* total number of entries in the central dir */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ number_entry_CD = uL;
++
++ if ((number_entry_CD!=us.gi.number_entry) ||
++ (number_disk_with_CD!=0) ||
++ (number_disk!=0))
++ err=UNZ_BADZIPFILE;
++
++ /* size of the central directory */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ us.size_central_dir = uL;
++
++ /* offset of start of central directory with respect to the
++ starting disk number */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ us.offset_central_dir = uL;
++
++ /* zipfile comment length */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
++ (err==UNZ_OK))
++ err=UNZ_BADZIPFILE;
++
++ if (err!=UNZ_OK)
++ {
++ ZCLOSE64(us.z_filefunc, us.filestream);
++ return NULL;
++ }
++
++ us.byte_before_the_zipfile = central_pos -
++ (us.offset_central_dir+us.size_central_dir);
++ us.central_pos = central_pos;
++ us.pfile_in_zip_read = NULL;
++ us.encrypted = 0;
++
++
++ s=(unz64_s*)ALLOC(sizeof(unz64_s));
++ if( s != NULL)
++ {
++ *s=us;
++ unzGoToFirstFile((unzFile)s);
++ }
++ return (unzFile)s;
++}
++
++
++extern unzFile ZEXPORT unzOpen2 (const char *path,
++ zlib_filefunc_def* pzlib_filefunc32_def)
++{
++ if (pzlib_filefunc32_def != NULL)
++ {
++ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
++ fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
++ return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
++ }
++ else
++ return unzOpenInternal(path, NULL, 0);
++}
++
++extern unzFile ZEXPORT unzOpen2_64 (const void *path,
++ zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ if (pzlib_filefunc_def != NULL)
++ {
++ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
++ zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
++ zlib_filefunc64_32_def_fill.ztell32_file = NULL;
++ zlib_filefunc64_32_def_fill.zseek32_file = NULL;
++ return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);
++ }
++ else
++ return unzOpenInternal(path, NULL, 1);
++}
++
++extern unzFile ZEXPORT unzOpen (const char *path)
++{
++ return unzOpenInternal(path, NULL, 0);
++}
++
++extern unzFile ZEXPORT unzOpen64 (const void *path)
++{
++ return unzOpenInternal(path, NULL, 1);
++}
++
++/*
++ Close a ZipFile opened with unzOpen.
++ If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
++ these files MUST be closed with unzCloseCurrentFile before call unzClose.
++ return UNZ_OK if there is no problem. */
++extern int ZEXPORT unzClose (unzFile file)
++{
++ unz64_s* s;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++
++ if (s->pfile_in_zip_read!=NULL)
++ unzCloseCurrentFile(file);
++
++ ZCLOSE64(s->z_filefunc, s->filestream);
++ TRYFREE(s);
++ return UNZ_OK;
++}
++
++
++/*
++ Write info about the ZipFile in the *pglobal_info structure.
++ No preparation of the structure is needed
++ return UNZ_OK if there is no problem. */
++extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)
++{
++ unz64_s* s;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ *pglobal_info=s->gi;
++ return UNZ_OK;
++}
++
++extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)
++{
++ unz64_s* s;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ /* to do : check if number_entry is not truncated */
++ pglobal_info32->number_entry = (uLong)s->gi.number_entry;
++ pglobal_info32->size_comment = s->gi.size_comment;
++ return UNZ_OK;
++}
++/*
++ Translate date/time from Dos format to tm_unz (readable more easilty)
++*/
++local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)
++{
++ ZPOS64_T uDate;
++ uDate = (ZPOS64_T)(ulDosDate>>16);
++ ptm->tm_mday = (uInt)(uDate&0x1f) ;
++ ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
++ ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
++
++ ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
++ ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
++ ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
++}
++
++/*
++ Get Info about the current file in the zipfile, with internal only info
++*/
++local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,
++ unz_file_info64 *pfile_info,
++ unz_file_info64_internal
++ *pfile_info_internal,
++ char *szFileName,
++ uLong fileNameBufferSize,
++ void *extraField,
++ uLong extraFieldBufferSize,
++ char *szComment,
++ uLong commentBufferSize));
++
++local int unz64local_GetCurrentFileInfoInternal (unzFile file,
++ unz_file_info64 *pfile_info,
++ unz_file_info64_internal
++ *pfile_info_internal,
++ char *szFileName,
++ uLong fileNameBufferSize,
++ void *extraField,
++ uLong extraFieldBufferSize,
++ char *szComment,
++ uLong commentBufferSize)
++{
++ unz64_s* s;
++ unz_file_info64 file_info;
++ unz_file_info64_internal file_info_internal;
++ int err=UNZ_OK;
++ uLong uMagic;
++ long lSeek=0;
++ uLong uL;
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (ZSEEK64(s->z_filefunc, s->filestream,
++ s->pos_in_central_dir+s->byte_before_the_zipfile,
++ ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err=UNZ_ERRNO;
++
++
++ /* we check the magic */
++ if (err==UNZ_OK)
++ {
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
++ err=UNZ_ERRNO;
++ else if (uMagic!=0x02014b50)
++ err=UNZ_BADZIPFILE;
++ }
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++ err=UNZ_ERRNO;
++ file_info.compressed_size = uL;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++ err=UNZ_ERRNO;
++ file_info.uncompressed_size = uL;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ // relative offset of local header
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++ err=UNZ_ERRNO;
++ file_info_internal.offset_curfile = uL;
++
++ lSeek+=file_info.size_filename;
++ if ((err==UNZ_OK) && (szFileName!=NULL))
++ {
++ uLong uSizeRead ;
++ if (file_info.size_filename<fileNameBufferSize)
++ {
++ *(szFileName+file_info.size_filename)='\0';
++ uSizeRead = file_info.size_filename;
++ }
++ else
++ uSizeRead = fileNameBufferSize;
++
++ if ((file_info.size_filename>0) && (fileNameBufferSize>0))
++ if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
++ err=UNZ_ERRNO;
++ lSeek -= uSizeRead;
++ }
++
++ // Read extrafield
++ if ((err==UNZ_OK) && (extraField!=NULL))
++ {
++ ZPOS64_T uSizeRead ;
++ if (file_info.size_file_extra<extraFieldBufferSize)
++ uSizeRead = file_info.size_file_extra;
++ else
++ uSizeRead = extraFieldBufferSize;
++
++ if (lSeek!=0)
++ {
++ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
++ lSeek=0;
++ else
++ err=UNZ_ERRNO;
++ }
++
++ if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
++ if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)
++ err=UNZ_ERRNO;
++
++ lSeek += file_info.size_file_extra - (uLong)uSizeRead;
++ }
++ else
++ lSeek += file_info.size_file_extra;
++
++
++ if ((err==UNZ_OK) && (file_info.size_file_extra != 0))
++ {
++ uLong acc = 0;
++
++ // since lSeek now points to after the extra field we need to move back
++ lSeek -= file_info.size_file_extra;
++
++ if (lSeek!=0)
++ {
++ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
++ lSeek=0;
++ else
++ err=UNZ_ERRNO;
++ }
++
++ while(acc < file_info.size_file_extra)
++ {
++ uLong headerId;
++ uLong dataSize;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* ZIP64 extra fields */
++ if (headerId == 0x0001)
++ {
++ uLong uL;
++
++ if(file_info.uncompressed_size == MAXU32)
++ {
++ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ if(file_info.compressed_size == MAXU32)
++ {
++ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ if(file_info_internal.offset_curfile == MAXU32)
++ {
++ /* Relative Header offset */
++ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ if(file_info.disk_num_start == MAXU32)
++ {
++ /* Disk Start Number */
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ }
++ else
++ {
++ if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)
++ err=UNZ_ERRNO;
++ }
++
++ acc += 2 + 2 + dataSize;
++ }
++ }
++
++ if ((err==UNZ_OK) && (szComment!=NULL))
++ {
++ uLong uSizeRead ;
++ if (file_info.size_file_comment<commentBufferSize)
++ {
++ *(szComment+file_info.size_file_comment)='\0';
++ uSizeRead = file_info.size_file_comment;
++ }
++ else
++ uSizeRead = commentBufferSize;
++
++ if (lSeek!=0)
++ {
++ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
++ lSeek=0;
++ else
++ err=UNZ_ERRNO;
++ }
++
++ if ((file_info.size_file_comment>0) && (commentBufferSize>0))
++ if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
++ err=UNZ_ERRNO;
++ lSeek+=file_info.size_file_comment - uSizeRead;
++ }
++ else
++ lSeek+=file_info.size_file_comment;
++
++
++ if ((err==UNZ_OK) && (pfile_info!=NULL))
++ *pfile_info=file_info;
++
++ if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
++ *pfile_info_internal=file_info_internal;
++
++ return err;
++}
++
++
++
++/*
++ Write info about the ZipFile in the *pglobal_info structure.
++ No preparation of the structure is needed
++ return UNZ_OK if there is no problem.
++*/
++extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file,
++ unz_file_info64 * pfile_info,
++ char * szFileName, uLong fileNameBufferSize,
++ void *extraField, uLong extraFieldBufferSize,
++ char* szComment, uLong commentBufferSize)
++{
++ return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,
++ szFileName,fileNameBufferSize,
++ extraField,extraFieldBufferSize,
++ szComment,commentBufferSize);
++}
++
++extern int ZEXPORT unzGetCurrentFileInfo (unzFile file,
++ unz_file_info * pfile_info,
++ char * szFileName, uLong fileNameBufferSize,
++ void *extraField, uLong extraFieldBufferSize,
++ char* szComment, uLong commentBufferSize)
++{
++ int err;
++ unz_file_info64 file_info64;
++ err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,
++ szFileName,fileNameBufferSize,
++ extraField,extraFieldBufferSize,
++ szComment,commentBufferSize);
++ if ((err==UNZ_OK) && (pfile_info != NULL))
++ {
++ pfile_info->version = file_info64.version;
++ pfile_info->version_needed = file_info64.version_needed;
++ pfile_info->flag = file_info64.flag;
++ pfile_info->compression_method = file_info64.compression_method;
++ pfile_info->dosDate = file_info64.dosDate;
++ pfile_info->crc = file_info64.crc;
++
++ pfile_info->size_filename = file_info64.size_filename;
++ pfile_info->size_file_extra = file_info64.size_file_extra;
++ pfile_info->size_file_comment = file_info64.size_file_comment;
++
++ pfile_info->disk_num_start = file_info64.disk_num_start;
++ pfile_info->internal_fa = file_info64.internal_fa;
++ pfile_info->external_fa = file_info64.external_fa;
++
++ pfile_info->tmu_date = file_info64.tmu_date,
++
++
++ pfile_info->compressed_size = (uLong)file_info64.compressed_size;
++ pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;
++
++ }
++ return err;
++}
++/*
++ Set the current file of the zipfile to the first file.
++ return UNZ_OK if there is no problem
++*/
++extern int ZEXPORT unzGoToFirstFile (unzFile file)
++{
++ int err=UNZ_OK;
++ unz64_s* s;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ s->pos_in_central_dir=s->offset_central_dir;
++ s->num_file=0;
++ err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
++ &s->cur_file_info_internal,
++ NULL,0,NULL,0,NULL,0);
++ s->current_file_ok = (err == UNZ_OK);
++ return err;
++}
++
++/*
++ Set the current file of the zipfile to the next file.
++ return UNZ_OK if there is no problem
++ return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
++*/
++extern int ZEXPORT unzGoToNextFile (unzFile file)
++{
++ unz64_s* s;
++ int err;
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return UNZ_END_OF_LIST_OF_FILE;
++ if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */
++ if (s->num_file+1==s->gi.number_entry)
++ return UNZ_END_OF_LIST_OF_FILE;
++
++ s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
++ s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
++ s->num_file++;
++ err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
++ &s->cur_file_info_internal,
++ NULL,0,NULL,0,NULL,0);
++ s->current_file_ok = (err == UNZ_OK);
++ return err;
++}
++
++
++/*
++ Try locate the file szFileName in the zipfile.
++ For the iCaseSensitivity signification, see unzStringFileNameCompare
++
++ return value :
++ UNZ_OK if the file is found. It becomes the current file.
++ UNZ_END_OF_LIST_OF_FILE if the file is not found
++*/
++extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
++{
++ unz64_s* s;
++ int err;
++
++ /* We remember the 'current' position in the file so that we can jump
++ * back there if we fail.
++ */
++ unz_file_info64 cur_file_infoSaved;
++ unz_file_info64_internal cur_file_info_internalSaved;
++ ZPOS64_T num_fileSaved;
++ ZPOS64_T pos_in_central_dirSaved;
++
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++
++ if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
++ return UNZ_PARAMERROR;
++
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return UNZ_END_OF_LIST_OF_FILE;
++
++ /* Save the current state */
++ num_fileSaved = s->num_file;
++ pos_in_central_dirSaved = s->pos_in_central_dir;
++ cur_file_infoSaved = s->cur_file_info;
++ cur_file_info_internalSaved = s->cur_file_info_internal;
++
++ err = unzGoToFirstFile(file);
++
++ while (err == UNZ_OK)
++ {
++ char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
++ err = unzGetCurrentFileInfo64(file,NULL,
++ szCurrentFileName,sizeof(szCurrentFileName)-1,
++ NULL,0,NULL,0);
++ if (err == UNZ_OK)
++ {
++ if (unzStringFileNameCompare(szCurrentFileName,
++ szFileName,iCaseSensitivity)==0)
++ return UNZ_OK;
++ err = unzGoToNextFile(file);
++ }
++ }
++
++ /* We failed, so restore the state of the 'current file' to where we
++ * were.
++ */
++ s->num_file = num_fileSaved ;
++ s->pos_in_central_dir = pos_in_central_dirSaved ;
++ s->cur_file_info = cur_file_infoSaved;
++ s->cur_file_info_internal = cur_file_info_internalSaved;
++ return err;
++}
++
++
++/*
++///////////////////////////////////////////
++// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
++// I need random access
++//
++// Further optimization could be realized by adding an ability
++// to cache the directory in memory. The goal being a single
++// comprehensive file read to put the file I need in a memory.
++*/
++
++/*
++typedef struct unz_file_pos_s
++{
++ ZPOS64_T pos_in_zip_directory; // offset in file
++ ZPOS64_T num_of_file; // # of file
++} unz_file_pos;
++*/
++
++extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos* file_pos)
++{
++ unz64_s* s;
++
++ if (file==NULL || file_pos==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return UNZ_END_OF_LIST_OF_FILE;
++
++ file_pos->pos_in_zip_directory = s->pos_in_central_dir;
++ file_pos->num_of_file = s->num_file;
++
++ return UNZ_OK;
++}
++
++extern int ZEXPORT unzGetFilePos(
++ unzFile file,
++ unz_file_pos* file_pos)
++{
++ unz64_file_pos file_pos64;
++ int err = unzGetFilePos64(file,&file_pos64);
++ if (err==UNZ_OK)
++ {
++ file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;
++ file_pos->num_of_file = (uLong)file_pos64.num_of_file;
++ }
++ return err;
++}
++
++extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)
++{
++ unz64_s* s;
++ int err;
++
++ if (file==NULL || file_pos==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++
++ /* jump to the right spot */
++ s->pos_in_central_dir = file_pos->pos_in_zip_directory;
++ s->num_file = file_pos->num_of_file;
++
++ /* set the current file */
++ err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
++ &s->cur_file_info_internal,
++ NULL,0,NULL,0,NULL,0);
++ /* return results */
++ s->current_file_ok = (err == UNZ_OK);
++ return err;
++}
++
++extern int ZEXPORT unzGoToFilePos(
++ unzFile file,
++ unz_file_pos* file_pos)
++{
++ unz64_file_pos file_pos64;
++ if (file_pos == NULL)
++ return UNZ_PARAMERROR;
++
++ file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
++ file_pos64.num_of_file = file_pos->num_of_file;
++ return unzGoToFilePos64(file,&file_pos64);
++}
++
++/*
++// Unzip Helper Functions - should be here?
++///////////////////////////////////////////
++*/
++
++/*
++ Read the local header of the current zipfile
++ Check the coherency of the local header and info in the end of central
++ directory about this file
++ store in *piSizeVar the size of extra info in local header
++ (filename and size of extra field data)
++*/
++local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar,
++ ZPOS64_T * poffset_local_extrafield,
++ uInt * psize_local_extrafield)
++{
++ uLong uMagic,uData,uFlags;
++ uLong size_filename;
++ uLong size_extra_field;
++ int err=UNZ_OK;
++
++ *piSizeVar = 0;
++ *poffset_local_extrafield = 0;
++ *psize_local_extrafield = 0;
++
++ if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
++ s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return UNZ_ERRNO;
++
++
++ if (err==UNZ_OK)
++ {
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
++ err=UNZ_ERRNO;
++ else if (uMagic!=0x04034b50)
++ err=UNZ_BADZIPFILE;
++ }
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
++ err=UNZ_ERRNO;
++/*
++ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
++ err=UNZ_BADZIPFILE;
++*/
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
++ err=UNZ_ERRNO;
++ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
++ err=UNZ_BADZIPFILE;
++
++ if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
++/* #ifdef HAVE_BZIP2 */
++ (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
++/* #endif */
++ (s->cur_file_info.compression_method!=Z_DEFLATED))
++ err=UNZ_BADZIPFILE;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
++ err=UNZ_ERRNO;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
++ err=UNZ_ERRNO;
++ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))
++ err=UNZ_BADZIPFILE;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
++ err=UNZ_ERRNO;
++ else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))
++ err=UNZ_BADZIPFILE;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
++ err=UNZ_ERRNO;
++ else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))
++ err=UNZ_BADZIPFILE;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
++ err=UNZ_ERRNO;
++ else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
++ err=UNZ_BADZIPFILE;
++
++ *piSizeVar += (uInt)size_filename;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
++ err=UNZ_ERRNO;
++ *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
++ SIZEZIPLOCALHEADER + size_filename;
++ *psize_local_extrafield = (uInt)size_extra_field;
++
++ *piSizeVar += (uInt)size_extra_field;
++
++ return err;
++}
++
++/*
++ Open for reading data the current file in the zipfile.
++ If there is no error and the file is opened, the return value is UNZ_OK.
++*/
++extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
++ int* level, int raw, const char* password)
++{
++ int err=UNZ_OK;
++ uInt iSizeVar;
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ ZPOS64_T offset_local_extrafield; /* offset of the local extra field */
++ uInt size_local_extrafield; /* size of the local extra field */
++# ifndef NOUNCRYPT
++ char source[12];
++# else
++ if (password != NULL)
++ return UNZ_PARAMERROR;
++# endif
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return UNZ_PARAMERROR;
++
++ if (s->pfile_in_zip_read != NULL)
++ unzCloseCurrentFile(file);
++
++ if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
++ return UNZ_BADZIPFILE;
++
++ pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));
++ if (pfile_in_zip_read_info==NULL)
++ return UNZ_INTERNALERROR;
++
++ pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
++ pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
++ pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
++ pfile_in_zip_read_info->pos_local_extrafield=0;
++ pfile_in_zip_read_info->raw=raw;
++
++ if (pfile_in_zip_read_info->read_buffer==NULL)
++ {
++ TRYFREE(pfile_in_zip_read_info);
++ return UNZ_INTERNALERROR;
++ }
++
++ pfile_in_zip_read_info->stream_initialised=0;
++
++ if (method!=NULL)
++ *method = (int)s->cur_file_info.compression_method;
++
++ if (level!=NULL)
++ {
++ *level = 6;
++ switch (s->cur_file_info.flag & 0x06)
++ {
++ case 6 : *level = 1; break;
++ case 4 : *level = 2; break;
... etc. - the rest is truncated
More information about the Libreoffice-commits
mailing list